* modules/packetizer/*: bug fix (use es_format_Copy() when necessary).
[vlc.git] / modules / packetizer / mpeg4video.c
1 /*****************************************************************************
2  * mpeg4video.c: mpeg 4 video packetizer
3  *****************************************************************************
4  * Copyright (C) 2001, 2002 VideoLAN
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *          Eric Petit <titer@videolan.org>
9  *          Gildas Bazin <gbazin@netcourrier.com>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
24  *****************************************************************************/
25
26 /*****************************************************************************
27  * Preamble
28  *****************************************************************************/
29 #include <stdlib.h>                                      /* malloc(), free() */
30
31 #include <vlc/vlc.h>
32 #include <vlc/decoder.h>
33 #include <vlc/sout.h>
34
35 #include "vlc_bits.h"
36
37 /*****************************************************************************
38  * Module descriptor
39  *****************************************************************************/
40 static int  Open ( vlc_object_t * );
41 static void Close( vlc_object_t * );
42
43 vlc_module_begin();
44     set_description( _("MPEG4 video packetizer") );
45     set_capability( "packetizer", 50 );
46     set_callbacks( Open, Close );
47 vlc_module_end();
48
49
50 /****************************************************************************
51  * Local prototypes
52  ****************************************************************************/
53 static block_t *Packetize( decoder_t *, block_t ** );
54
55 struct decoder_sys_t
56 {
57     /*
58      * Common properties
59      */
60     mtime_t i_pts;
61     mtime_t i_dts;
62
63
64     vlc_bool_t  b_vop;
65     int         i_buffer;
66     int         i_buffer_size;
67     uint8_t     *p_buffer;
68     unsigned int i_flags;
69
70     vlc_bool_t  b_frame;
71 };
72
73 static int m4v_FindStartCode( uint8_t **pp_start, uint8_t *p_end );
74 static int m4v_VOLParse( es_format_t *fmt, uint8_t *p_vol, int i_vol );
75
76 #define VIDEO_OBJECT_MASK                       0x01f
77 #define VIDEO_OBJECT_LAYER_MASK                 0x00f
78
79 #define VIDEO_OBJECT_START_CODE                 0x100
80 #define VIDEO_OBJECT_LAYER_START_CODE           0x120
81 #define VISUAL_OBJECT_SEQUENCE_START_CODE       0x1b0
82 #define VISUAL_OBJECT_SEQUENCE_END_CODE         0x1b1
83 #define USER_DATA_START_CODE                    0x1b2
84 #define GROUP_OF_VOP_START_CODE                 0x1b3
85 #define VIDEO_SESSION_ERROR_CODE                0x1b4
86 #define VISUAL_OBJECT_START_CODE                0x1b5
87 #define VOP_START_CODE                          0x1b6
88 #define FACE_OBJECT_START_CODE                  0x1ba
89 #define FACE_OBJECT_PLANE_START_CODE            0x1bb
90 #define MESH_OBJECT_START_CODE                  0x1bc
91 #define MESH_OBJECT_PLANE_START_CODE            0x1bd
92 #define STILL_TEXTURE_OBJECT_START_CODE         0x1be
93 #define TEXTURE_SPATIAL_LAYER_START_CODE        0x1bf
94 #define TEXTURE_SNR_LAYER_START_CODE            0x1c0
95
96 /*****************************************************************************
97  * Open: probe the packetizer and return score
98  *****************************************************************************/
99 static int Open( vlc_object_t *p_this )
100 {
101     decoder_t     *p_dec = (decoder_t*)p_this;
102     decoder_sys_t *p_sys;
103
104     switch( p_dec->fmt_in.i_codec )
105     {
106         case VLC_FOURCC( 'm', '4', 's', '2'):
107         case VLC_FOURCC( 'M', '4', 'S', '2'):
108         case VLC_FOURCC( 'm', 'p', '4', 's'):
109         case VLC_FOURCC( 'M', 'P', '4', 'S'):
110         case VLC_FOURCC( 'm', 'p', '4', 'v'):
111         case VLC_FOURCC( 'D', 'I', 'V', 'X'):
112         case VLC_FOURCC( 'd', 'i', 'v', 'x'):
113         case VLC_FOURCC( 'X', 'V', 'I', 'D'):
114         case VLC_FOURCC( 'X', 'v', 'i', 'D'):
115         case VLC_FOURCC( 'x', 'v', 'i', 'd'):
116         case VLC_FOURCC( 'D', 'X', '5', '0'):
117         case VLC_FOURCC( 'd', 'x', '5', '0'):
118         case VLC_FOURCC( 0x04, 0,   0,   0):
119         case VLC_FOURCC( '3', 'I', 'V', '2'):
120         case VLC_FOURCC( 'm', '4', 'c', 'c'):
121         case VLC_FOURCC( 'M', '4', 'C', 'C'):
122             break;
123
124         default:
125             return VLC_EGENERIC;
126     }
127
128     /* Allocate the memory needed to store the decoder's structure */
129     if( ( p_dec->p_sys = p_sys = malloc( sizeof(decoder_sys_t) ) ) == NULL )
130     {
131         msg_Err( p_dec, "out of memory" );
132         return VLC_EGENERIC;
133     }
134     p_sys->i_pts = 0;
135     p_sys->i_dts = 0;
136     p_sys->b_vop = VLC_FALSE;
137     p_sys->i_buffer = 0;
138     p_sys->i_buffer_size = 0;
139     p_sys->p_buffer = 0;
140     p_sys->i_flags = 0;
141     p_sys->b_frame = VLC_FALSE;
142
143     /* Setup properties */
144     es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
145     p_dec->fmt_out.i_codec = VLC_FOURCC( 'm', 'p', '4', 'v' );
146
147     if( p_dec->fmt_in.i_extra )
148     {
149         /* We have a vol */
150         p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
151         p_dec->fmt_out.p_extra = malloc( p_dec->fmt_in.i_extra );
152         memcpy( p_dec->fmt_out.p_extra, p_dec->fmt_in.p_extra,
153                 p_dec->fmt_in.i_extra );
154
155         msg_Dbg( p_dec, "opening with vol size:%d", p_dec->fmt_in.i_extra );
156         m4v_VOLParse( &p_dec->fmt_out,
157                       p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
158     }
159     else
160     {
161         /* No vol, we'll have to look for one later on */
162         p_dec->fmt_out.i_extra = 0;
163         p_dec->fmt_out.p_extra = 0;
164     }
165
166     /* Set callback */
167     p_dec->pf_packetize = Packetize;
168
169     return VLC_SUCCESS;
170 }
171
172 /*****************************************************************************
173  * Close: clean up the packetizer
174  *****************************************************************************/
175 static void Close( vlc_object_t *p_this )
176 {
177     decoder_t *p_dec = (decoder_t*)p_this;
178
179     if( p_dec->p_sys->p_buffer ) free( p_dec->p_sys->p_buffer );
180     free( p_dec->p_sys );
181 }
182
183 /****************************************************************************
184  * Packetize: the whole thing
185  ****************************************************************************/
186 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
187 {
188     decoder_sys_t *p_sys = p_dec->p_sys;
189
190     block_t *p_chain_out = NULL;
191     block_t *p_block;
192     uint8_t *p_vol = NULL;
193     uint8_t *p_start;
194
195     if( !pp_block || !*pp_block ) return NULL;
196
197     p_block = *pp_block;
198
199     /* Append data */
200     if( p_sys->i_buffer + p_block->i_buffer > p_sys->i_buffer_size )
201     {
202         p_sys->i_buffer_size += p_block->i_buffer + 1024;
203         p_sys->p_buffer = realloc( p_sys->p_buffer, p_sys->i_buffer_size );
204     }
205     memcpy( &p_sys->p_buffer[p_sys->i_buffer], p_block->p_buffer,
206             p_block->i_buffer );
207     p_sys->i_buffer += p_block->i_buffer;
208
209     if( p_sys->i_buffer > 10*1000000 )
210     {
211         msg_Err( p_dec, "mmh reseting context" );
212         p_sys->i_buffer = 0;
213     }
214
215     /* Search vop */
216     p_start = &p_sys->p_buffer[p_sys->i_buffer - p_block->i_buffer - 4];
217     if( p_start < p_sys->p_buffer )
218     {
219         p_start = p_sys->p_buffer;
220     }
221     for( ;; )
222     {
223         if( m4v_FindStartCode( &p_start, &p_sys->p_buffer[p_sys->i_buffer] ) )
224         {
225             block_Release( p_block );
226             *pp_block = NULL;
227             return p_chain_out;
228         }
229         /* fprintf( stderr, "start code=0x1%2.2x\n", p_start[3] ); */
230
231         if( p_vol )
232         {
233             /* Copy the complete VOL */
234             p_dec->fmt_out.i_extra = p_start - p_vol;
235             p_dec->fmt_out.p_extra = malloc( p_dec->fmt_out.i_extra );
236             memcpy( p_dec->fmt_out.p_extra, p_vol, p_dec->fmt_out.i_extra );
237             m4v_VOLParse( &p_dec->fmt_out,
238                           p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
239
240             p_vol = NULL;
241         }
242         if( p_sys->b_vop )
243         {
244             /* Output the complete VOP we have */
245             int     i_out = p_start - p_sys->p_buffer;
246             block_t *p_out = block_New( p_dec, i_out );
247
248             /* extract data */
249             memcpy( p_out->p_buffer, p_sys->p_buffer, i_out );
250             if( i_out < p_sys->i_buffer )
251             {
252                 memmove( p_sys->p_buffer, &p_sys->p_buffer[i_out],
253                          p_sys->i_buffer - i_out );
254             }
255             p_sys->i_buffer -= i_out;
256             p_start -= i_out;
257
258             p_out->i_flags = p_sys->i_flags;
259
260             /* FIXME do proper dts/pts */
261             p_out->i_pts = p_sys->i_pts;
262             p_out->i_dts = p_sys->i_dts;
263             /* FIXME doesn't work when there is multiple VOP in one block */
264             if( p_block->i_dts > p_sys->i_dts )
265             {
266                 p_out->i_length = p_block->i_dts - p_sys->i_dts;
267             }
268
269             if( p_dec->fmt_out.i_extra > 0 )
270             {
271                 block_ChainAppend( &p_chain_out, p_out );
272             }
273             else
274             {
275                 msg_Warn( p_dec, "waiting for VOL" );
276                 block_Release( p_out );
277             }
278
279 #if 0
280             fprintf( stderr, "pts=%lld dts=%lld length=%lldms\n",
281                      p_out->i_pts, p_out->i_dts,
282                      p_out->i_length / 1000 );
283 #endif
284             p_sys->b_vop = VLC_FALSE;
285         }
286
287         if( p_start[3] >= 0x20 && p_start[3] <= 0x2f )
288         {
289             /* Start of the VOL */
290             p_vol = p_start;
291         }
292         else if( p_start[3] == 0xb6 )
293         {
294             p_sys->b_vop = VLC_TRUE;
295             switch( p_start[4] >> 6 )
296             {
297                 case 0:
298                     p_sys->i_flags = BLOCK_FLAG_TYPE_I;
299                     break;
300                 case 1:
301                     p_sys->i_flags = BLOCK_FLAG_TYPE_P;
302                     break;
303                 case 2:
304                     p_sys->i_flags = BLOCK_FLAG_TYPE_B;
305                     p_sys->b_frame = VLC_TRUE;
306                     break;
307                 case 3: /* gni ? */
308                     p_sys->i_flags = BLOCK_FLAG_TYPE_PB;
309                     break;
310             }
311
312             /* The pts information is not available in all the containers.
313              * FIXME: calculate the pts correctly */
314             if( p_block->i_pts > 0 )
315             {
316                 p_sys->i_pts = p_block->i_pts;
317             }
318             else if( (p_sys->i_flags&BLOCK_FLAG_TYPE_B) || !p_sys->b_frame )
319             {
320                 p_sys->i_pts = p_block->i_dts;
321             }
322             else
323             {
324                 p_sys->i_pts = 0;
325             }
326             if( p_block->i_dts > 0 )
327             {
328                 p_sys->i_dts = p_block->i_dts;
329             }
330             else if( p_sys->i_dts > 0 )
331             {
332                 /* XXX KLUDGE immonde, else transcode won't work */
333                 p_sys->i_dts += 1000;
334             }
335         }
336         p_start += 4; /* Next */
337     }
338 }
339
340 /****************************************************************************
341  * m4v_FindStartCode
342  ****************************************************************************/
343 static int m4v_FindStartCode( uint8_t **pp_start, uint8_t *p_end )
344 {
345     uint8_t *p = *pp_start;
346
347     /* We wait for 4+1 bytes */
348     for( p = *pp_start; p < p_end - 5; p++ )
349     {
350         if( p[0] == 0 && p[1] == 0 && p[2] == 1 )
351         {
352             *pp_start = p;
353             return VLC_SUCCESS;
354         }
355     }
356
357     *pp_start = p_end;
358     return VLC_EGENERIC;
359 }
360
361
362 /* look at ffmpeg av_log2 ;) */
363 static int vlc_log2( unsigned int v )
364 {
365     int n = 0;
366     static const int vlc_log2_table[16] =
367     {
368         0,0,1,1,2,2,2,2, 3,3,3,3,3,3,3,3
369     };
370
371     if( v&0xffff0000 )
372     {
373         v >>= 16;
374         n += 16;
375     }
376     if( v&0xff00 )
377     {
378         v >>= 8;
379         n += 8;
380     }
381     if( v&0xf0 )
382     {
383         v >>= 4;
384         n += 4;
385     }
386     n += vlc_log2_table[v];
387
388     return n;
389 }
390
391 /* m4v_VOLParse:
392  *  TODO:
393  *      - support aspect ratio
394  */
395 static int m4v_VOLParse( es_format_t *fmt, uint8_t *p_vol, int i_vol )
396 {
397     bs_t s;
398     int i_vo_type;
399     int i_vo_ver_id;
400     int i_ar;
401     int i_shape;
402     int i_time_increment_resolution;
403
404     for( ;; )
405     {
406         if( p_vol[0] == 0x00 && p_vol[1] == 0x00 &&
407             p_vol[2] == 0x01 &&
408             p_vol[3] >= 0x20 && p_vol[3] <= 0x2f )
409         {
410             break;
411         }
412         p_vol++;
413         i_vol--;
414         if( i_vol <= 4 )
415         {
416             return VLC_EGENERIC;
417         }
418     }
419
420     /* parse the vol */
421     bs_init( &s, &p_vol[4], i_vol - 4 );
422
423     bs_skip( &s, 1 );   /* random access */
424     i_vo_type = bs_read( &s, 8 );
425     if( bs_read1( &s ) )
426     {
427         i_vo_ver_id = bs_read( &s, 4 );
428         bs_skip( &s, 3 );
429     }
430     else
431     {
432         i_vo_ver_id = 1;
433     }
434     i_ar = bs_read( &s, 4 );
435     if( i_ar == 0xf )
436     {
437         int i_ar_width, i_ar_height;
438
439         i_ar_width = bs_read( &s, 8 );
440         i_ar_height= bs_read( &s, 8 );
441     }
442     if( bs_read1( &s ) )
443     {
444         int i_chroma_format;
445         int i_low_delay;
446
447         /* vol control parameter */
448         i_chroma_format = bs_read( &s, 2 );
449         i_low_delay = bs_read1( &s );
450
451         if( bs_read1( &s ) )
452         {
453             bs_skip( &s, 16 );
454             bs_skip( &s, 16 );
455             bs_skip( &s, 16 );
456             bs_skip( &s, 3 );
457             bs_skip( &s, 11 );
458             bs_skip( &s, 1 );
459             bs_skip( &s, 16 );
460         }
461     }
462     /* shape 0->RECT, 1->BIN, 2->BIN_ONLY, 3->GRAY */
463     i_shape = bs_read( &s, 2 );
464     if( i_shape == 3 && i_vo_ver_id != 1 )
465     {
466         bs_skip( &s, 4 );
467     }
468
469     if( !bs_read1( &s ) )
470     {
471         /* marker */
472         return VLC_EGENERIC;
473     }
474     i_time_increment_resolution = bs_read( &s, 16 );
475     if( !bs_read1( &s ) )
476     {
477         /* marker */
478         return VLC_EGENERIC;
479     }
480
481     if( bs_read1( &s ) )
482     {
483         int i_time_increment_bits = vlc_log2( i_time_increment_resolution - 1 ) + 1;
484         if( i_time_increment_bits < 1 )
485         {
486             i_time_increment_bits = 1;
487         }
488         bs_skip( &s, i_time_increment_bits );
489     }
490     if( i_shape == 0 )
491     {
492         bs_skip( &s, 1 );
493         fmt->video.i_width = bs_read( &s, 13 );
494         bs_skip( &s, 1 );
495         fmt->video.i_height= bs_read( &s, 13 );
496         bs_skip( &s, 1 );
497     }
498     return VLC_SUCCESS;
499 }
500
501
502