* modules/packetizer/h264.c: oops, forgot to remove a bit of debug code.
[vlc.git] / modules / packetizer / h264.c
1 /*****************************************************************************
2  * h264.c: h264/avc 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@videolan.org>
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_block_helper.h"
36 #include "vlc_bits.h"
37
38 /*****************************************************************************
39  * Module descriptor
40  *****************************************************************************/
41 static int  Open ( vlc_object_t * );
42 static void Close( vlc_object_t * );
43
44 vlc_module_begin();
45     set_description( _("H264 video packetizer") );
46     set_capability( "packetizer", 50 );
47     set_callbacks( Open, Close );
48 vlc_module_end();
49
50
51 /****************************************************************************
52  * Local prototypes
53  ****************************************************************************/
54 static block_t *Packetize( decoder_t *, block_t ** );
55 static block_t *PacketizeAVC1( decoder_t *, block_t ** );
56
57 struct decoder_sys_t
58 {
59     block_bytestream_t bytestream;
60
61     int     i_state;
62     int     i_offset;
63     uint8_t startcode[4];
64
65     vlc_bool_t b_slice;
66     block_t    *p_frame;
67
68     int64_t      i_dts;
69     int64_t      i_pts;
70     unsigned int i_flags;
71
72     vlc_bool_t   b_sps;
73
74     /* avcC data */
75     int i_avcC_length_size;
76
77     /* Useful values of the Sequence Parameter Set */
78     int i_log2_max_frame_num;
79     int b_frame_mbs_only;
80
81     /* Useful values of the Slice Header */
82     int i_nal_type;
83     int i_nal_ref_idc;
84     int i_idr_pic_id;
85     int i_frame_num;
86 };
87
88 enum
89 {
90     STATE_NOSYNC,
91     STATE_NEXT_SYNC,
92 };
93
94 enum nal_unit_type_e
95 {
96     NAL_UNKNOWN = 0,
97     NAL_SLICE   = 1,
98     NAL_SLICE_DPA   = 2,
99     NAL_SLICE_DPB   = 3,
100     NAL_SLICE_DPC   = 4,
101     NAL_SLICE_IDR   = 5,    /* ref_idc != 0 */
102     NAL_SEI         = 6,    /* ref_idc == 0 */
103     NAL_SPS         = 7,
104     NAL_PPS         = 8
105     /* ref_idc == 0 for 6,9,10,11,12 */
106 };
107
108 enum nal_priority_e
109 {
110     NAL_PRIORITY_DISPOSABLE = 0,
111     NAL_PRIORITY_LOW        = 1,
112     NAL_PRIORITY_HIGH       = 2,
113     NAL_PRIORITY_HIGHEST    = 3,
114 };
115
116 static block_t *ParseNALBlock( decoder_t *, block_t * );
117
118 static block_t *nal_get_annexeb( decoder_t *, uint8_t *p, int );
119
120 /*****************************************************************************
121  * Open: probe the packetizer and return score
122  *****************************************************************************/
123 static int Open( vlc_object_t *p_this )
124 {
125     decoder_t     *p_dec = (decoder_t*)p_this;
126     decoder_sys_t *p_sys;
127
128     if( p_dec->fmt_in.i_codec != VLC_FOURCC( 'h', '2', '6', '4') &&
129         p_dec->fmt_in.i_codec != VLC_FOURCC( 'H', '2', '6', '4') &&
130         p_dec->fmt_in.i_codec != VLC_FOURCC( 'V', 'S', 'S', 'H') &&
131         p_dec->fmt_in.i_codec != VLC_FOURCC( 'v', 's', 's', 'h') &&
132         ( p_dec->fmt_in.i_codec != VLC_FOURCC( 'a', 'v', 'c', '1') ||
133           p_dec->fmt_in.i_extra < 7 ) )
134     {
135         return VLC_EGENERIC;
136     }
137
138     /* Allocate the memory needed to store the decoder's structure */
139     if( ( p_dec->p_sys = p_sys = malloc( sizeof(decoder_sys_t) ) ) == NULL )
140     {
141         msg_Err( p_dec, "out of memory" );
142         return VLC_EGENERIC;
143     }
144     p_sys->i_state = STATE_NOSYNC;
145     p_sys->i_offset = 0;
146     p_sys->startcode[0] = 0;
147     p_sys->startcode[1] = 0;
148     p_sys->startcode[2] = 0;
149     p_sys->startcode[3] = 1;
150     p_sys->bytestream = block_BytestreamInit( p_dec );
151     p_sys->b_slice = VLC_FALSE;
152     p_sys->p_frame = NULL;
153     p_sys->i_dts   = 0;
154     p_sys->i_pts   = 0;
155     p_sys->i_flags = 0;
156     p_sys->b_sps   = VLC_FALSE;
157
158     p_sys->i_nal_type = -1;
159     p_sys->i_nal_ref_idc = -1;
160     p_sys->i_idr_pic_id = -1;
161     p_sys->i_frame_num = -1;
162
163     /* Setup properties */
164     es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
165     p_dec->fmt_out.i_codec = VLC_FOURCC( 'h', '2', '6', '4' );
166     /* FIXME: FFMPEG isn't happy at all if you leave this */
167     if( p_dec->fmt_out.i_extra ) free( p_dec->fmt_out.p_extra );
168     p_dec->fmt_out.i_extra = 0; p_dec->fmt_out.p_extra = 0;
169
170     if( p_dec->fmt_in.i_codec == VLC_FOURCC( 'a', 'v', 'c', '1' ) )
171     {
172         uint8_t *p = &((uint8_t*)p_dec->fmt_in.p_extra)[4];
173         int i_sps, i_pps;
174         int i;
175
176         /* Parse avcC */
177         p_sys->i_avcC_length_size = 1 + ((*p++)&0x03);
178
179         /* Read SPS */
180         i_sps = (*p++)&0x1f;
181
182         for( i = 0; i < i_sps; i++ )
183         {
184             int i_length = GetWBE( p );
185             block_t *p_sps = nal_get_annexeb( p_dec, p + 2, i_length );
186
187             ParseNALBlock( p_dec, p_sps );
188             p += 2 + i_length;
189         }
190         /* Read PPS */
191         i_pps = *p++;
192         for( i = 0; i < i_pps; i++ )
193         {
194             int i_length = GetWBE( p );
195             block_t *p_pps = nal_get_annexeb( p_dec, p + 2, i_length );
196
197             ParseNALBlock( p_dec, p_pps );
198             p += 2 + i_length;
199         }
200         msg_Dbg( p_dec, "avcC length size=%d sps=%d pps=%d",
201                  p_sys->i_avcC_length_size, i_sps, i_pps );
202
203         /* Set callback */
204         p_dec->pf_packetize = PacketizeAVC1;
205     }
206     else
207     {
208         /* Set callback */
209         p_dec->pf_packetize = Packetize;
210     }
211
212     return VLC_SUCCESS;
213 }
214
215 /*****************************************************************************
216  * Close: clean up the packetizer
217  *****************************************************************************/
218 static void Close( vlc_object_t *p_this )
219 {
220     decoder_t *p_dec = (decoder_t*)p_this;
221     decoder_sys_t *p_sys = p_dec->p_sys;
222
223     block_BytestreamRelease( &p_sys->bytestream );
224     free( p_sys );
225 }
226
227 /****************************************************************************
228  * Packetize: the whole thing
229  ****************************************************************************/
230 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
231 {
232     decoder_sys_t *p_sys = p_dec->p_sys;
233     block_t       *p_pic;
234
235     if( !pp_block || !*pp_block ) return NULL;
236
237     block_BytestreamPush( &p_sys->bytestream, *pp_block );
238
239     for( ;; )
240     {
241         switch( p_sys->i_state )
242         {
243             case STATE_NOSYNC:
244                 if( block_FindStartcodeFromOffset( &p_sys->bytestream,
245                       &p_sys->i_offset, p_sys->startcode+1, 3 ) == VLC_SUCCESS)
246                 {
247                     p_sys->i_state = STATE_NEXT_SYNC;
248                 }
249
250                 if( p_sys->i_offset )
251                 {
252                     block_SkipBytes( &p_sys->bytestream, p_sys->i_offset );
253                     p_sys->i_offset = 0;
254                     block_BytestreamFlush( &p_sys->bytestream );
255                 }
256
257                 if( p_sys->i_state != STATE_NEXT_SYNC )
258                 {
259                     /* Need more data */
260                     return NULL;
261                 }
262
263                 p_sys->i_offset = 1; /* To find next startcode */
264
265             case STATE_NEXT_SYNC:
266                 /* Find the next startcode */
267                 if( block_FindStartcodeFromOffset( &p_sys->bytestream,
268                       &p_sys->i_offset, p_sys->startcode, 3 ) != VLC_SUCCESS)
269                 {
270                     if( block_FindStartcodeFromOffset( &p_sys->bytestream,
271                           &p_sys->i_offset, p_sys->startcode+1, 3 ) !=
272                         VLC_SUCCESS )
273                     {
274                         /* Need more data */
275                         return NULL;
276                     }
277                 }
278
279                 /* Get the new fragment and set the pts/dts */
280                 p_pic = block_New( p_dec, p_sys->i_offset );
281                 p_pic->i_pts = p_sys->bytestream.p_block->i_pts;
282                 p_pic->i_dts = p_sys->bytestream.p_block->i_dts;
283
284                 block_GetBytes( &p_sys->bytestream, p_pic->p_buffer,
285                                 p_pic->i_buffer );
286
287                 p_sys->i_offset = 0;
288
289                 /* Parse the NAL */
290                 if( !( p_pic = ParseNALBlock( p_dec, p_pic ) ) )
291                 {
292                     p_sys->i_state = STATE_NOSYNC;
293                     break;
294                 }
295
296                 /* So p_block doesn't get re-added several times */
297                 *pp_block = block_BytestreamPop( &p_sys->bytestream );
298
299                 p_sys->i_state = STATE_NOSYNC;
300
301                 return p_pic;
302         }
303     }
304 }
305
306 /****************************************************************************
307  * PacketizeAVC1: the whole thing
308  ****************************************************************************/
309 static block_t *PacketizeAVC1( decoder_t *p_dec, block_t **pp_block )
310 {
311     decoder_sys_t *p_sys = p_dec->p_sys;
312     block_t       *p_block;
313     block_t       *p_ret = NULL;
314     uint8_t       *p;
315
316     if( !pp_block || !*pp_block ) return NULL;
317
318     p_block = *pp_block;
319     *pp_block = NULL;
320
321     for( p = p_block->p_buffer; p < &p_block->p_buffer[p_block->i_buffer]; )
322     {
323         block_t *p_pic;
324         int i_size = 0;
325         int i;
326
327         for( i = 0; i < p_sys->i_avcC_length_size; i++ )
328         {
329             i_size = (i_size << 8) | (*p++);
330         }
331
332         if( i_size > 0 )
333         {
334             block_t *p_part = nal_get_annexeb( p_dec, p, i_size );
335
336             p_part->i_dts = p_block->i_dts;
337             p_part->i_pts = p_block->i_pts;
338
339             /* Parse the NAL */
340             if( ( p_pic = ParseNALBlock( p_dec, p_part ) ) )
341             {
342                 block_ChainAppend( &p_ret, p_pic );
343             }
344         }
345         p += i_size;
346     }
347
348     return p_ret;
349 }
350
351 static block_t *nal_get_annexeb( decoder_t *p_dec, uint8_t *p, int i_size )
352 {
353     block_t *p_nal;
354
355     p_nal = block_New( p_dec, 3 + i_size );
356
357     /* Add start code */
358     p_nal->p_buffer[0] = 0x00;
359     p_nal->p_buffer[1] = 0x00;
360     p_nal->p_buffer[2] = 0x01;
361
362     /* Copy nalu */
363     memcpy( &p_nal->p_buffer[3], p, i_size );
364
365     return p_nal;
366 }
367
368 static void nal_get_decoded( uint8_t **pp_ret, int *pi_ret,
369                              uint8_t *src, int i_src )
370 {
371     uint8_t *end = &src[i_src];
372     uint8_t *dst = malloc( i_src );
373
374     *pp_ret = dst;
375
376     while( src < end )
377     {
378         if( src < end - 3 && src[0] == 0x00 && src[1] == 0x00 &&
379             src[2] == 0x03 )
380         {
381             *dst++ = 0x00;
382             *dst++ = 0x00;
383
384             src += 3;
385             continue;
386         }
387         *dst++ = *src++;
388     }
389
390     *pi_ret = dst - *pp_ret;
391 }
392
393 static inline int bs_read_ue( bs_t *s )
394 {
395     int i = 0;
396
397     while( bs_read1( s ) == 0 && s->p < s->p_end && i < 32 )
398     {
399         i++;
400     }
401     return( ( 1 << i) - 1 + bs_read( s, i ) );
402 }
403
404 static inline int bs_read_se( bs_t *s )
405 {
406     int val = bs_read_ue( s );
407
408     return val&0x01 ? (val+1)/2 : -(val/2);
409 }
410
411
412 static block_t *ParseNALBlock( decoder_t *p_dec, block_t *p_frag )
413 {
414     decoder_sys_t *p_sys = p_dec->p_sys;
415     block_t *p_pic = NULL;
416
417     const int i_nal_ref_idc = (p_frag->p_buffer[3] >> 5)&0x03;
418     const int i_nal_type = p_frag->p_buffer[3]&0x1f;
419
420     if( p_sys->b_slice && !p_sys->b_sps )
421     {
422         block_ChainRelease( p_sys->p_frame );
423         msg_Warn( p_dec, "waiting for SPS" );
424
425         /* Reset context */
426         p_sys->p_frame = NULL;
427         p_sys->b_slice = VLC_FALSE;
428     }
429
430     if( !p_sys->b_sps &&
431         i_nal_type >= NAL_SLICE && i_nal_type <= NAL_SLICE_IDR )
432     {
433         p_sys->b_slice = VLC_TRUE;
434         /* Fragment will be discarded later on */
435     }
436     else if( i_nal_type >= NAL_SLICE && i_nal_type <= NAL_SLICE_IDR )
437     {
438         uint8_t *dec;
439         int i_dec, i_first_mb, i_slice_type, i_frame_num, i_pic_flags = 0;
440         vlc_bool_t b_pic = VLC_FALSE;
441         bs_t s;
442
443         /* do not convert the whole frame */
444         nal_get_decoded( &dec, &i_dec, &p_frag->p_buffer[4],
445                          __MIN( p_frag->i_buffer - 4, 60 ) );
446         bs_init( &s, dec, i_dec );
447
448         /* first_mb_in_slice */
449         i_first_mb = bs_read_ue( &s );
450
451         /* slice_type */
452         switch( (i_slice_type = bs_read_ue( &s )) )
453         {
454             case 0: case 5:
455                 i_pic_flags = BLOCK_FLAG_TYPE_P;
456                 break;
457             case 1: case 6:
458                 i_pic_flags = BLOCK_FLAG_TYPE_B;
459                 break;
460             case 2: case 7:
461                 i_pic_flags = BLOCK_FLAG_TYPE_I;
462                 break;
463             case 3: case 8: /* SP */
464                 i_pic_flags = BLOCK_FLAG_TYPE_P;
465                 break;
466             case 4: case 9:
467                 i_pic_flags = BLOCK_FLAG_TYPE_I;
468                 break;
469         }
470
471         /* pic_parameter_set_id */
472         bs_read_ue( &s );
473         /* frame_num */
474         i_frame_num = bs_read( &s, p_sys->i_log2_max_frame_num + 4 );
475
476         /* Detection of the first VCL NAL unit of a primary coded picture
477          * (cf. 7.4.1.2.4) */
478         if( i_frame_num != p_sys->i_frame_num ||
479             ( (i_nal_ref_idc != p_sys->i_nal_ref_idc) &&
480               (!i_nal_ref_idc || !p_sys->i_nal_ref_idc) ) )
481         {
482             b_pic = VLC_TRUE;
483         }
484         p_sys->i_frame_num = i_frame_num;
485         p_sys->i_nal_ref_idc = i_nal_ref_idc;
486
487         if( !p_sys->b_frame_mbs_only )
488         {
489             /* field_pic_flag */
490             if( bs_read( &s, 1 ) )
491             {
492                 /* bottom_field_flag */
493                 bs_read( &s, 1 );
494             }
495         }
496
497         if( i_nal_type == NAL_SLICE_IDR )
498         {
499             /* id_pic_id */
500             int i_idr_pic_id = bs_read_ue( &s );
501             if( p_sys->i_nal_type != i_nal_type ) b_pic = VLC_TRUE;
502             if( p_sys->i_idr_pic_id != i_idr_pic_id ) b_pic = VLC_TRUE;
503             p_sys->i_idr_pic_id = i_idr_pic_id;
504         }
505         p_sys->i_nal_type = i_nal_type;
506
507         if( b_pic && p_sys->b_slice )
508         {
509             p_pic = block_ChainGather( p_sys->p_frame );
510             p_pic->i_dts = p_sys->i_dts;
511             p_pic->i_pts = p_sys->i_pts;
512             p_pic->i_length = 0;    /* FIXME */
513             p_pic->i_flags = p_sys->i_flags;
514
515             /* Reset context */
516             p_sys->p_frame = NULL;
517             p_sys->b_slice = VLC_FALSE;
518         }
519
520         p_sys->b_slice = VLC_TRUE;
521         p_sys->i_flags = i_pic_flags;
522         p_sys->i_dts   = p_frag->i_dts;
523         p_sys->i_pts   = p_frag->i_pts;
524
525         free( dec );
526     }
527     else if( i_nal_type == NAL_SPS )
528     {
529         uint8_t *dec;
530         int     i_dec;
531         bs_t s;
532         int i_tmp;
533
534         msg_Dbg( p_dec, "found NAL_SPS" );
535
536         p_sys->b_sps = VLC_TRUE;
537
538         nal_get_decoded( &dec, &i_dec, &p_frag->p_buffer[4],
539                          p_frag->i_buffer - 4 );
540
541         bs_init( &s, dec, i_dec );
542         /* Skip profile(8), constraint_set012, reserver(5), level(8) */
543         bs_skip( &s, 8 + 1+1+1 + 5 + 8 );
544         /* sps id */
545         bs_read_ue( &s );
546         /* Skip i_log2_max_frame_num */
547         p_sys->i_log2_max_frame_num = bs_read_ue( &s );
548         /* Read poc_type */
549         i_tmp = bs_read_ue( &s );
550         if( i_tmp == 0 )
551         {
552             /* skip i_log2_max_poc_lsb */
553             bs_read_ue( &s );
554         }
555         else if( i_tmp == 1 )
556         {
557             int i_cycle;
558             /* skip b_delta_pic_order_always_zero */
559             bs_skip( &s, 1 );
560             /* skip i_offset_for_non_ref_pic */
561             bs_read_se( &s );
562             /* skip i_offset_for_top_to_bottom_field */
563             bs_read_se( &s );
564             /* read i_num_ref_frames_in_poc_cycle */
565             i_cycle = bs_read_ue( &s );
566             if( i_cycle > 256 ) i_cycle = 256;
567             while( i_cycle > 0 )
568             {
569                 /* skip i_offset_for_ref_frame */
570                 bs_read_se(&s );
571             }
572         }
573         /* i_num_ref_frames */
574         bs_read_ue( &s );
575         /* b_gaps_in_frame_num_value_allowed */
576         bs_skip( &s, 1 );
577
578         /* Read size */
579         p_dec->fmt_out.video.i_width  = 16 * ( bs_read_ue( &s ) + 1 );
580         p_dec->fmt_out.video.i_height = 16 * ( bs_read_ue( &s ) + 1 );
581
582         /* b_frame_mbs_only */
583         p_sys->b_frame_mbs_only = bs_read( &s, 1 );
584         if( p_sys->b_frame_mbs_only == 0 )
585         {
586             bs_skip( &s, 1 );
587         }
588         /* b_direct8x8_inference */
589         bs_skip( &s, 1 );
590
591         /* crop */
592         i_tmp = bs_read( &s, 1 );
593         if( i_tmp )
594         {
595             /* left */
596             bs_read_ue( &s );
597             /* right */
598             bs_read_ue( &s );
599             /* top */
600             bs_read_ue( &s );
601             /* bottom */
602             bs_read_ue( &s );
603         }
604
605         /* vui */
606         i_tmp = bs_read( &s, 1 );
607         if( i_tmp )
608         {
609             /* read the aspect ratio part if any FIXME check it */
610             i_tmp = bs_read( &s, 1 );
611             if( i_tmp )
612             {
613                 static const struct { int w, h; } sar[14] =
614                 {
615                     { 0,   0 }, { 1,   1 }, { 12, 11 }, { 10, 11 },
616                     { 16, 11 }, { 40, 33 }, { 24, 11 }, { 20, 11 },
617                     { 32, 11 }, { 80, 33 }, { 18, 11 }, { 15, 11 },
618                     { 64, 33 }, { 160,99 },
619                 };
620                 int i_sar = bs_read( &s, 8 );
621                 int w, h;
622
623                 if( i_sar < 14 )
624                 {
625                     w = sar[i_sar].w;
626                     h = sar[i_sar].h;
627                 }
628                 else
629                 {
630                     w = bs_read( &s, 16 );
631                     h = bs_read( &s, 16 );
632                 }
633                 p_dec->fmt_out.video.i_aspect =
634                     VOUT_ASPECT_FACTOR * w / h * p_dec->fmt_out.video.i_width /
635                     p_dec->fmt_out.video.i_height;
636             }
637         }
638
639         free( dec );
640     }
641     else if( i_nal_type == NAL_PPS )
642     {
643         bs_t s;
644         bs_init( &s, &p_frag->p_buffer[4], p_frag->i_buffer - 4 );
645
646         /* TODO */
647         msg_Dbg( p_dec, "found NAL_PPS" );
648     }
649
650     /* Append the block */
651     block_ChainAppend( &p_sys->p_frame, p_frag );
652
653     return p_pic;
654 }