1 /*****************************************************************************
2 * rtpfmt.c: RTP payload formats
3 *****************************************************************************
4 * Copyright (C) 2003-2004 the VideoLAN team
5 * Copyright © 2007 Rémi Denis-Courmont
8 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
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.
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.
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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
29 #include <vlc_common.h>
31 #include <vlc_block.h>
36 rtp_packetize_h264_nal( sout_stream_id_t *id,
37 const uint8_t *p_data, int i_data, int64_t i_pts,
38 int64_t i_dts, bool b_last, int64_t i_length );
40 int rtp_packetize_mpa( sout_stream_id_t *id,
43 int i_max = rtp_mtu (id) - 4; /* payload max in one packet */
44 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
46 uint8_t *p_data = in->p_buffer;
47 int i_data = in->i_buffer;
50 for( i = 0; i < i_count; i++ )
52 int i_payload = __MIN( i_max, i_data );
53 block_t *out = block_Alloc( 16 + i_payload );
55 /* rtp common header */
56 rtp_packetize_common( id, out, (i == i_count - 1)?1:0, in->i_pts );
58 SetWBE( out->p_buffer + 12, 0 );
59 /* fragment offset in the current frame */
60 SetWBE( out->p_buffer + 14, i * i_max );
61 memcpy( &out->p_buffer[16], p_data, i_payload );
63 out->i_buffer = 16 + i_payload;
64 out->i_dts = in->i_dts + i * in->i_length / i_count;
65 out->i_length = in->i_length / i_count;
67 rtp_packetize_send( id, out );
77 int rtp_packetize_mpv( sout_stream_id_t *id, block_t *in )
79 int i_max = rtp_mtu (id) - 4; /* payload max in one packet */
80 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
82 uint8_t *p_data = in->p_buffer;
83 int i_data = in->i_buffer;
85 int b_sequence_start = 0;
86 int i_temporal_ref = 0;
87 int i_picture_coding_type = 0;
88 int i_fbv = 0, i_bfc = 0, i_ffv = 0, i_ffc = 0;
89 int b_start_slice = 0;
91 /* preparse this packet to get some info */
92 if( in->i_buffer > 4 )
95 int i_rest = in->i_buffer;
100 ( p[0] != 0x00 || p[1] != 0x00 || p[2] != 0x01 ) )
114 /* sequence start code */
115 b_sequence_start = 1;
117 else if( *p == 0x00 && i_rest >= 4 )
120 i_temporal_ref = ( p[1] << 2) |((p[2]>>6)&0x03);
121 i_picture_coding_type = (p[2] >> 3)&0x07;
123 if( i_rest >= 4 && ( i_picture_coding_type == 2 ||
124 i_picture_coding_type == 3 ) )
126 i_ffv = (p[3] >> 2)&0x01;
127 i_ffc = ((p[3]&0x03) << 1)|((p[4]>>7)&0x01);
128 if( i_rest > 4 && i_picture_coding_type == 3 )
130 i_fbv = (p[4]>>6)&0x01;
131 i_bfc = (p[4]>>3)&0x07;
135 else if( *p <= 0xaf )
142 for( i = 0; i < i_count; i++ )
144 int i_payload = __MIN( i_max, i_data );
145 block_t *out = block_Alloc( 16 + i_payload );
146 /* MBZ:5 T:1 TR:10 AN:1 N:1 S:1 B:1 E:1 P:3 FBV:1 BFC:3 FFV:1 FFC:3 */
147 uint32_t h = ( i_temporal_ref << 16 )|
148 ( b_sequence_start << 13 )|
149 ( b_start_slice << 12 )|
150 ( i == i_count - 1 ? 1 << 11 : 0 )|
151 ( i_picture_coding_type << 8 )|
152 ( i_fbv << 7 )|( i_bfc << 4 )|( i_ffv << 3 )|i_ffc;
154 /* rtp common header */
155 rtp_packetize_common( id, out, (i == i_count - 1)?1:0,
156 in->i_pts > 0 ? in->i_pts : in->i_dts );
158 SetDWBE( out->p_buffer + 12, h );
160 memcpy( &out->p_buffer[16], p_data, i_payload );
162 out->i_buffer = 16 + i_payload;
163 out->i_dts = in->i_dts + i * in->i_length / i_count;
164 out->i_length = in->i_length / i_count;
166 rtp_packetize_send( id, out );
175 int rtp_packetize_ac3( sout_stream_id_t *id, block_t *in )
177 int i_max = rtp_mtu (id) - 2; /* payload max in one packet */
178 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
180 uint8_t *p_data = in->p_buffer;
181 int i_data = in->i_buffer;
184 for( i = 0; i < i_count; i++ )
186 int i_payload = __MIN( i_max, i_data );
187 block_t *out = block_Alloc( 14 + i_payload );
189 /* rtp common header */
190 rtp_packetize_common( id, out, (i == i_count - 1)?1:0, in->i_pts );
192 out->p_buffer[12] = 1;
194 out->p_buffer[13] = 0x00;
196 memcpy( &out->p_buffer[14], p_data, i_payload );
198 out->i_buffer = 14 + i_payload;
199 out->i_dts = in->i_dts + i * in->i_length / i_count;
200 out->i_length = in->i_length / i_count;
202 rtp_packetize_send( id, out );
211 int rtp_packetize_split( sout_stream_id_t *id, block_t *in )
213 int i_max = rtp_mtu (id); /* payload max in one packet */
214 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
216 uint8_t *p_data = in->p_buffer;
217 int i_data = in->i_buffer;
220 for( i = 0; i < i_count; i++ )
222 int i_payload = __MIN( i_max, i_data );
223 block_t *out = block_Alloc( 12 + i_payload );
225 /* rtp common header */
226 rtp_packetize_common( id, out, (i == i_count - 1),
227 (in->i_pts > 0 ? in->i_pts : in->i_dts) );
228 memcpy( &out->p_buffer[12], p_data, i_payload );
230 out->i_buffer = 12 + i_payload;
231 out->i_dts = in->i_dts + i * in->i_length / i_count;
232 out->i_length = in->i_length / i_count;
234 rtp_packetize_send( id, out );
244 int rtp_packetize_mp4a_latm( sout_stream_id_t *id, block_t *in )
246 int i_max = rtp_mtu (id) - 2; /* payload max in one packet */
247 int latmhdrsize = in->i_buffer / 0xff + 1;
248 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
250 uint8_t *p_data = in->p_buffer, *p_header = NULL;
251 int i_data = in->i_buffer;
254 for( i = 0; i < i_count; i++ )
256 int i_payload = __MIN( i_max, i_data );
261 out = block_Alloc( 12 + latmhdrsize + i_payload );
263 /* rtp common header */
264 rtp_packetize_common( id, out, ((i == i_count - 1) ? 1 : 0),
265 (in->i_pts > 0 ? in->i_pts : in->i_dts) );
269 int tmp = in->i_buffer;
271 p_header=out->p_buffer+12;
281 memcpy( &out->p_buffer[12+latmhdrsize], p_data, i_payload );
283 out->i_buffer = 12 + latmhdrsize + i_payload;
284 out->i_dts = in->i_dts + i * in->i_length / i_count;
285 out->i_length = in->i_length / i_count;
287 rtp_packetize_send( id, out );
296 int rtp_packetize_mp4a( sout_stream_id_t *id, block_t *in )
298 int i_max = rtp_mtu (id) - 4; /* payload max in one packet */
299 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
301 uint8_t *p_data = in->p_buffer;
302 int i_data = in->i_buffer;
305 for( i = 0; i < i_count; i++ )
307 int i_payload = __MIN( i_max, i_data );
308 block_t *out = block_Alloc( 16 + i_payload );
310 /* rtp common header */
311 rtp_packetize_common( id, out, ((i == i_count - 1)?1:0),
312 (in->i_pts > 0 ? in->i_pts : in->i_dts) );
314 /* AU headers length (bits) */
315 out->p_buffer[12] = 0;
316 out->p_buffer[13] = 2*8;
317 /* for each AU length 13 bits + idx 3bits, */
318 SetWBE( out->p_buffer + 14, (in->i_buffer << 3) | 0 );
320 memcpy( &out->p_buffer[16], p_data, i_payload );
322 out->i_buffer = 16 + i_payload;
323 out->i_dts = in->i_dts + i * in->i_length / i_count;
324 out->i_length = in->i_length / i_count;
326 rtp_packetize_send( id, out );
337 #define RTP_H263_HEADER_SIZE (2) // plen = 0
338 #define RTP_H263_PAYLOAD_START (14) // plen = 0
339 int rtp_packetize_h263( sout_stream_id_t *id, block_t *in )
341 uint8_t *p_data = in->p_buffer;
342 int i_data = in->i_buffer;
344 int i_max = rtp_mtu (id) - RTP_H263_HEADER_SIZE; /* payload max in one packet */
347 int b_v_bit = 0; // no pesky error resilience
348 int i_plen = 0; // normally plen=0 for PSC packet
349 int i_pebit = 0; // because plen=0
356 if( p_data[0] || p_data[1] )
360 /* remove 2 leading 0 bytes */
363 i_count = ( i_data + i_max - 1 ) / i_max;
365 for( i = 0; i < i_count; i++ )
367 int i_payload = __MIN( i_max, i_data );
368 block_t *out = block_Alloc( RTP_H263_PAYLOAD_START + i_payload );
369 b_p_bit = (i == 0) ? 1 : 0;
370 h = ( b_p_bit << 10 )|
375 /* rtp common header */
376 //b_m_bit = 1; // always contains end of frame
377 rtp_packetize_common( id, out, (i == i_count - 1)?1:0,
378 in->i_pts > 0 ? in->i_pts : in->i_dts );
381 SetWBE( out->p_buffer + 12, h );
382 memcpy( &out->p_buffer[RTP_H263_PAYLOAD_START], p_data, i_payload );
384 out->i_buffer = RTP_H263_PAYLOAD_START + i_payload;
385 out->i_dts = in->i_dts + i * in->i_length / i_count;
386 out->i_length = in->i_length / i_count;
388 rtp_packetize_send( id, out );
399 rtp_packetize_h264_nal( sout_stream_id_t *id,
400 const uint8_t *p_data, int i_data, int64_t i_pts,
401 int64_t i_dts, bool b_last, int64_t i_length )
403 const int i_max = rtp_mtu (id); /* payload max in one packet */
410 i_nal_hdr = p_data[3];
411 i_nal_type = i_nal_hdr&0x1f;
413 /* Skip start code */
418 if( i_data <= i_max )
420 /* Single NAL unit packet */
421 block_t *out = block_Alloc( 12 + i_data );
423 out->i_length = i_length;
426 rtp_packetize_common( id, out, b_last, i_pts );
427 out->i_buffer = 12 + i_data;
429 memcpy( &out->p_buffer[12], p_data, i_data );
431 rtp_packetize_send( id, out );
435 /* FU-A Fragmentation Unit without interleaving */
436 const int i_count = ( i_data-1 + i_max-2 - 1 ) / (i_max-2);
442 for( i = 0; i < i_count; i++ )
444 const int i_payload = __MIN( i_data, i_max-2 );
445 block_t *out = block_Alloc( 12 + 2 + i_payload );
446 out->i_dts = i_dts + i * i_length / i_count;
447 out->i_length = i_length / i_count;
450 rtp_packetize_common( id, out, (b_last && i_payload == i_data), i_pts );
451 out->i_buffer = 14 + i_payload;
454 out->p_buffer[12] = 0x00 | (i_nal_hdr & 0x60) | 28;
456 out->p_buffer[13] = ( i == 0 ? 0x80 : 0x00 ) | ( (i == i_count-1) ? 0x40 : 0x00 ) | i_nal_type;
457 memcpy( &out->p_buffer[14], p_data, i_payload );
459 rtp_packetize_send( id, out );
468 int rtp_packetize_h264( sout_stream_id_t *id, block_t *in )
470 const uint8_t *p_buffer = in->p_buffer;
471 int i_buffer = in->i_buffer;
473 while( i_buffer > 4 && ( p_buffer[0] != 0 || p_buffer[1] != 0 || p_buffer[2] != 1 ) )
479 /* Split nal units */
480 while( i_buffer > 4 )
483 int i_size = i_buffer;
484 int i_skip = i_buffer;
487 for( i_offset = 4; i_offset+2 < i_buffer ; i_offset++)
489 if( p_buffer[i_offset] == 0 && p_buffer[i_offset+1] == 0 && p_buffer[i_offset+2] == 1 )
491 /* we found another startcode */
492 i_size = i_offset - ( p_buffer[i_offset-1] == 0 ? 1 : 0);
497 /* TODO add STAP-A to remove a lot of overhead with small slice/sei/... */
498 rtp_packetize_h264_nal( id, p_buffer, i_size,
499 (in->i_pts > 0 ? in->i_pts : in->i_dts), in->i_dts,
500 (i_size >= i_buffer), in->i_length * i_size / in->i_buffer );
508 int rtp_packetize_amr( sout_stream_id_t *id, block_t *in )
510 int i_max = rtp_mtu (id) - 2; /* payload max in one packet */
511 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
513 uint8_t *p_data = in->p_buffer;
514 int i_data = in->i_buffer;
517 /* Only supports octet-aligned mode */
518 for( i = 0; i < i_count; i++ )
520 int i_payload = __MIN( i_max, i_data );
521 block_t *out = block_Alloc( 14 + i_payload );
523 /* rtp common header */
524 rtp_packetize_common( id, out, ((i == i_count - 1)?1:0),
525 (in->i_pts > 0 ? in->i_pts : in->i_dts) );
527 out->p_buffer[12] = 0xF0; /* CMR */
528 out->p_buffer[13] = p_data[0]&0x7C; /* ToC */ /* FIXME: frame type */
530 /* FIXME: are we fed multiple frames ? */
531 memcpy( &out->p_buffer[14], p_data+1, i_payload-1 );
533 out->i_buffer = 14 + i_payload-1;
534 out->i_dts = in->i_dts + i * in->i_length / i_count;
535 out->i_length = in->i_length / i_count;
537 rtp_packetize_send( id, out );
546 int rtp_packetize_t140( sout_stream_id_t *id, block_t *in )
548 const size_t i_max = rtp_mtu (id);
549 const uint8_t *p_data = in->p_buffer;
550 size_t i_data = in->i_buffer;
552 for( unsigned i_packet = 0; i_data > 0; i_packet++ )
554 size_t i_payload = i_data;
556 /* Make sure we stop on an UTF-8 character boundary
557 * (assuming the input is valid UTF-8) */
562 while( ( p_data[i_payload] & 0xC0 ) == 0x80 )
565 return VLC_SUCCESS; /* fishy input! */
571 block_t *out = block_Alloc( 12 + i_payload );
575 rtp_packetize_common( id, out, 0, in->i_pts + i_packet );
576 memcpy( out->p_buffer + 12, p_data, i_payload );
578 out->i_buffer = 12 + i_payload;
579 out->i_dts = out->i_pts;
582 rtp_packetize_send( id, out );
592 int rtp_packetize_spx( sout_stream_id_t *id, block_t *in )
594 uint8_t *p_buffer = in->p_buffer;
595 int i_data_size, i_payload_size, i_payload_padding;
596 i_data_size = i_payload_size = in->i_buffer;
597 i_payload_padding = 0;
600 if ( in->i_buffer > rtp_mtu (id) )
604 RFC for Speex in RTP says that each packet must end on an octet
605 boundary. So, we check to see if the number of bytes % 4 is zero.
606 If not, we have to add some padding.
608 This MAY be overkill since packetization is handled elsewhere and
609 appears to ensure the octet boundary. However, better safe than
612 if ( i_payload_size % 4 )
614 i_payload_padding = 4 - ( i_payload_size % 4 );
615 i_payload_size += i_payload_padding;
619 Allocate a new RTP p_output block of the appropriate size.
620 Allow for 12 extra bytes of RTP header.
622 p_out = block_Alloc( 12 + i_payload_size );
624 if ( i_payload_padding )
627 The padding is required to be a zero followed by all 1s.
629 char c_first_pad, c_remaining_pad;
631 c_remaining_pad = 0xFF;
634 Allow for 12 bytes before the i_data_size because
635 of the expected RTP header added during
636 rtp_packetize_common.
638 p_out->p_buffer[12 + i_data_size] = c_first_pad;
639 switch (i_payload_padding)
642 p_out->p_buffer[12 + i_data_size + 1] = c_remaining_pad;
645 p_out->p_buffer[12 + i_data_size + 1] = c_remaining_pad;
646 p_out->p_buffer[12 + i_data_size + 2] = c_remaining_pad;
651 /* Add the RTP header to our p_output buffer. */
652 rtp_packetize_common( id, p_out, 0, (in->i_pts > 0 ? in->i_pts : in->i_dts) );
653 /* Copy the Speex payload to the p_output buffer */
654 memcpy( &p_out->p_buffer[12], p_buffer, i_data_size );
656 p_out->i_buffer = 12 + i_payload_size;
657 p_out->i_dts = in->i_dts;
658 p_out->i_length = in->i_length;
660 /* Queue the buffer for actual transmission. */
661 rtp_packetize_send( id, p_out );
665 static int rtp_packetize_g726( sout_stream_id_t *id, block_t *in, int i_pad )
667 int i_max = (rtp_mtu( id )- 12 + i_pad - 1) & ~i_pad;
668 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
670 uint8_t *p_data = in->p_buffer;
671 int i_data = in->i_buffer;
676 int i_payload = __MIN( i_max, i_data );
677 block_t *out = block_New( p_stream, 12 + i_payload );
679 /* rtp common header */
680 rtp_packetize_common( id, out, 0,
681 (in->i_pts > 0 ? in->i_pts : in->i_dts) );
683 memcpy( &out->p_buffer[12], p_data, i_payload );
685 out->i_buffer = 12 + i_payload;
686 out->i_dts = in->i_dts + i_packet++ * in->i_length / i_count;
687 out->i_length = in->i_length / i_count;
689 rtp_packetize_send( id, out );
697 int rtp_packetize_g726_16( sout_stream_id_t *id, block_t *in )
699 return rtp_packetize_g726( id, in, 4 );
702 int rtp_packetize_g726_24( sout_stream_id_t *id, block_t *in )
704 return rtp_packetize_g726( id, in, 8 );
707 int rtp_packetize_g726_32( sout_stream_id_t *id, block_t *in )
709 return rtp_packetize_g726( id, in, 2 );
712 int rtp_packetize_g726_40( sout_stream_id_t *id, block_t *in )
714 return rtp_packetize_g726( id, in, 8 );