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 out->p_buffer[12] = 0;
59 out->p_buffer[13] = 0;
60 /* fragment offset in the current frame */
61 out->p_buffer[14] = ( (i*i_max) >> 8 )&0xff;
62 out->p_buffer[15] = ( (i*i_max) )&0xff;
63 memcpy( &out->p_buffer[16], p_data, i_payload );
65 out->i_buffer = 16 + i_payload;
66 out->i_dts = in->i_dts + i * in->i_length / i_count;
67 out->i_length = in->i_length / i_count;
69 rtp_packetize_send( id, out );
79 int rtp_packetize_mpv( sout_stream_id_t *id, block_t *in )
81 int i_max = rtp_mtu (id) - 4; /* payload max in one packet */
82 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
84 uint8_t *p_data = in->p_buffer;
85 int i_data = in->i_buffer;
87 int b_sequence_start = 0;
88 int i_temporal_ref = 0;
89 int i_picture_coding_type = 0;
90 int i_fbv = 0, i_bfc = 0, i_ffv = 0, i_ffc = 0;
91 int b_start_slice = 0;
93 /* preparse this packet to get some info */
94 if( in->i_buffer > 4 )
97 int i_rest = in->i_buffer;
102 ( p[0] != 0x00 || p[1] != 0x00 || p[2] != 0x01 ) )
116 /* sequence start code */
117 b_sequence_start = 1;
119 else if( *p == 0x00 && i_rest >= 4 )
122 i_temporal_ref = ( p[1] << 2) |((p[2]>>6)&0x03);
123 i_picture_coding_type = (p[2] >> 3)&0x07;
125 if( i_rest >= 4 && ( i_picture_coding_type == 2 ||
126 i_picture_coding_type == 3 ) )
128 i_ffv = (p[3] >> 2)&0x01;
129 i_ffc = ((p[3]&0x03) << 1)|((p[4]>>7)&0x01);
130 if( i_rest > 4 && i_picture_coding_type == 3 )
132 i_fbv = (p[4]>>6)&0x01;
133 i_bfc = (p[4]>>3)&0x07;
137 else if( *p <= 0xaf )
144 for( i = 0; i < i_count; i++ )
146 int i_payload = __MIN( i_max, i_data );
147 block_t *out = block_Alloc( 16 + i_payload );
148 uint32_t h = ( i_temporal_ref << 16 )|
149 ( b_sequence_start << 13 )|
150 ( b_start_slice << 12 )|
151 ( i == i_count - 1 ? 1 << 11 : 0 )|
152 ( i_picture_coding_type << 8 )|
153 ( i_fbv << 7 )|( i_bfc << 4 )|( i_ffv << 3 )|i_ffc;
155 /* rtp common header */
156 rtp_packetize_common( id, out, (i == i_count - 1)?1:0,
157 in->i_pts > 0 ? in->i_pts : in->i_dts );
159 /* 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 */
160 out->p_buffer[12] = ( h >> 24 )&0xff;
161 out->p_buffer[13] = ( h >> 16 )&0xff;
162 out->p_buffer[14] = ( h >> 8 )&0xff;
163 out->p_buffer[15] = ( h )&0xff;
165 memcpy( &out->p_buffer[16], p_data, i_payload );
167 out->i_buffer = 16 + i_payload;
168 out->i_dts = in->i_dts + i * in->i_length / i_count;
169 out->i_length = in->i_length / i_count;
171 rtp_packetize_send( id, out );
180 int rtp_packetize_ac3( sout_stream_id_t *id, block_t *in )
182 int i_max = rtp_mtu (id) - 2; /* payload max in one packet */
183 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
185 uint8_t *p_data = in->p_buffer;
186 int i_data = in->i_buffer;
189 for( i = 0; i < i_count; i++ )
191 int i_payload = __MIN( i_max, i_data );
192 block_t *out = block_Alloc( 14 + i_payload );
194 /* rtp common header */
195 rtp_packetize_common( id, out, (i == i_count - 1)?1:0, in->i_pts );
197 out->p_buffer[12] = 1;
199 out->p_buffer[13] = 0x00;
201 memcpy( &out->p_buffer[14], p_data, i_payload );
203 out->i_buffer = 14 + i_payload;
204 out->i_dts = in->i_dts + i * in->i_length / i_count;
205 out->i_length = in->i_length / i_count;
207 rtp_packetize_send( id, out );
216 int rtp_packetize_split( sout_stream_id_t *id, block_t *in )
218 int i_max = rtp_mtu (id); /* payload max in one packet */
219 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
221 uint8_t *p_data = in->p_buffer;
222 int i_data = in->i_buffer;
225 for( i = 0; i < i_count; i++ )
227 int i_payload = __MIN( i_max, i_data );
228 block_t *out = block_Alloc( 12 + i_payload );
230 /* rtp common header */
231 rtp_packetize_common( id, out, (i == i_count - 1),
232 (in->i_pts > 0 ? in->i_pts : in->i_dts) );
233 memcpy( &out->p_buffer[12], p_data, i_payload );
235 out->i_buffer = 12 + i_payload;
236 out->i_dts = in->i_dts + i * in->i_length / i_count;
237 out->i_length = in->i_length / i_count;
239 rtp_packetize_send( id, out );
249 int rtp_packetize_mp4a_latm( sout_stream_id_t *id, block_t *in )
251 int i_max = rtp_mtu (id) - 2; /* payload max in one packet */
252 int latmhdrsize = in->i_buffer / 0xff + 1;
253 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
255 uint8_t *p_data = in->p_buffer, *p_header = NULL;
256 int i_data = in->i_buffer;
259 for( i = 0; i < i_count; i++ )
261 int i_payload = __MIN( i_max, i_data );
266 out = block_Alloc( 12 + latmhdrsize + i_payload );
268 /* rtp common header */
269 rtp_packetize_common( id, out, ((i == i_count - 1) ? 1 : 0),
270 (in->i_pts > 0 ? in->i_pts : in->i_dts) );
274 int tmp = in->i_buffer;
276 p_header=out->p_buffer+12;
286 memcpy( &out->p_buffer[12+latmhdrsize], p_data, i_payload );
288 out->i_buffer = 12 + latmhdrsize + i_payload;
289 out->i_dts = in->i_dts + i * in->i_length / i_count;
290 out->i_length = in->i_length / i_count;
292 rtp_packetize_send( id, out );
301 int rtp_packetize_mp4a( sout_stream_id_t *id, block_t *in )
303 int i_max = rtp_mtu (id) - 4; /* payload max in one packet */
304 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
306 uint8_t *p_data = in->p_buffer;
307 int i_data = in->i_buffer;
310 for( i = 0; i < i_count; i++ )
312 int i_payload = __MIN( i_max, i_data );
313 block_t *out = block_Alloc( 16 + i_payload );
315 /* rtp common header */
316 rtp_packetize_common( id, out, ((i == i_count - 1)?1:0),
317 (in->i_pts > 0 ? in->i_pts : in->i_dts) );
319 /* AU headers length (bits) */
320 out->p_buffer[12] = 0;
321 out->p_buffer[13] = 2*8;
322 /* for each AU length 13 bits + idx 3bits, */
323 out->p_buffer[14] = ( in->i_buffer >> 5 )&0xff;
324 out->p_buffer[15] = ( (in->i_buffer&0xff)<<3 )|0;
326 memcpy( &out->p_buffer[16], p_data, i_payload );
328 out->i_buffer = 16 + i_payload;
329 out->i_dts = in->i_dts + i * in->i_length / i_count;
330 out->i_length = in->i_length / i_count;
332 rtp_packetize_send( id, out );
343 #define RTP_H263_HEADER_SIZE (2) // plen = 0
344 #define RTP_H263_PAYLOAD_START (14) // plen = 0
345 int rtp_packetize_h263( sout_stream_id_t *id, block_t *in )
347 uint8_t *p_data = in->p_buffer;
348 int i_data = in->i_buffer;
350 int i_max = rtp_mtu (id) - RTP_H263_HEADER_SIZE; /* payload max in one packet */
353 int b_v_bit = 0; // no pesky error resilience
354 int i_plen = 0; // normally plen=0 for PSC packet
355 int i_pebit = 0; // because plen=0
362 if( p_data[0] || p_data[1] )
366 /* remove 2 leading 0 bytes */
369 i_count = ( i_data + i_max - 1 ) / i_max;
371 for( i = 0; i < i_count; i++ )
373 int i_payload = __MIN( i_max, i_data );
374 block_t *out = block_Alloc( RTP_H263_PAYLOAD_START + i_payload );
375 b_p_bit = (i == 0) ? 1 : 0;
376 h = ( b_p_bit << 10 )|
381 /* rtp common header */
382 //b_m_bit = 1; // always contains end of frame
383 rtp_packetize_common( id, out, (i == i_count - 1)?1:0,
384 in->i_pts > 0 ? in->i_pts : in->i_dts );
387 out->p_buffer[12] = ( h >> 8 )&0xff;
388 out->p_buffer[13] = ( h )&0xff;
389 memcpy( &out->p_buffer[RTP_H263_PAYLOAD_START], p_data, i_payload );
391 out->i_buffer = RTP_H263_PAYLOAD_START + i_payload;
392 out->i_dts = in->i_dts + i * in->i_length / i_count;
393 out->i_length = in->i_length / i_count;
395 rtp_packetize_send( id, out );
406 rtp_packetize_h264_nal( sout_stream_id_t *id,
407 const uint8_t *p_data, int i_data, int64_t i_pts,
408 int64_t i_dts, bool b_last, int64_t i_length )
410 const int i_max = rtp_mtu (id); /* payload max in one packet */
417 i_nal_hdr = p_data[3];
418 i_nal_type = i_nal_hdr&0x1f;
420 /* Skip start code */
425 if( i_data <= i_max )
427 /* Single NAL unit packet */
428 block_t *out = block_Alloc( 12 + i_data );
430 out->i_length = i_length;
433 rtp_packetize_common( id, out, b_last, i_pts );
434 out->i_buffer = 12 + i_data;
436 memcpy( &out->p_buffer[12], p_data, i_data );
438 rtp_packetize_send( id, out );
442 /* FU-A Fragmentation Unit without interleaving */
443 const int i_count = ( i_data-1 + i_max-2 - 1 ) / (i_max-2);
449 for( i = 0; i < i_count; i++ )
451 const int i_payload = __MIN( i_data, i_max-2 );
452 block_t *out = block_Alloc( 12 + 2 + i_payload );
453 out->i_dts = i_dts + i * i_length / i_count;
454 out->i_length = i_length / i_count;
457 rtp_packetize_common( id, out, (b_last && i_payload == i_data), i_pts );
458 out->i_buffer = 14 + i_payload;
461 out->p_buffer[12] = 0x00 | (i_nal_hdr & 0x60) | 28;
463 out->p_buffer[13] = ( i == 0 ? 0x80 : 0x00 ) | ( (i == i_count-1) ? 0x40 : 0x00 ) | i_nal_type;
464 memcpy( &out->p_buffer[14], p_data, i_payload );
466 rtp_packetize_send( id, out );
475 int rtp_packetize_h264( sout_stream_id_t *id, block_t *in )
477 const uint8_t *p_buffer = in->p_buffer;
478 int i_buffer = in->i_buffer;
480 while( i_buffer > 4 && ( p_buffer[0] != 0 || p_buffer[1] != 0 || p_buffer[2] != 1 ) )
486 /* Split nal units */
487 while( i_buffer > 4 )
490 int i_size = i_buffer;
491 int i_skip = i_buffer;
494 for( i_offset = 4; i_offset+2 < i_buffer ; i_offset++)
496 if( p_buffer[i_offset] == 0 && p_buffer[i_offset+1] == 0 && p_buffer[i_offset+2] == 1 )
498 /* we found another startcode */
499 i_size = i_offset - ( p_buffer[i_offset-1] == 0 ? 1 : 0);
504 /* TODO add STAP-A to remove a lot of overhead with small slice/sei/... */
505 rtp_packetize_h264_nal( id, p_buffer, i_size,
506 (in->i_pts > 0 ? in->i_pts : in->i_dts), in->i_dts,
507 (i_size >= i_buffer), in->i_length * i_size / in->i_buffer );
515 int rtp_packetize_amr( sout_stream_id_t *id, block_t *in )
517 int i_max = rtp_mtu (id) - 2; /* payload max in one packet */
518 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
520 uint8_t *p_data = in->p_buffer;
521 int i_data = in->i_buffer;
524 /* Only supports octet-aligned mode */
525 for( i = 0; i < i_count; i++ )
527 int i_payload = __MIN( i_max, i_data );
528 block_t *out = block_Alloc( 14 + i_payload );
530 /* rtp common header */
531 rtp_packetize_common( id, out, ((i == i_count - 1)?1:0),
532 (in->i_pts > 0 ? in->i_pts : in->i_dts) );
534 out->p_buffer[12] = 0xF0; /* CMR */
535 out->p_buffer[13] = p_data[0]&0x7C; /* ToC */ /* FIXME: frame type */
537 /* FIXME: are we fed multiple frames ? */
538 memcpy( &out->p_buffer[14], p_data+1, i_payload-1 );
540 out->i_buffer = 14 + i_payload-1;
541 out->i_dts = in->i_dts + i * in->i_length / i_count;
542 out->i_length = in->i_length / i_count;
544 rtp_packetize_send( id, out );
553 int rtp_packetize_t140( sout_stream_id_t *id, block_t *in )
555 const size_t i_max = rtp_mtu (id);
556 const uint8_t *p_data = in->p_buffer;
557 size_t i_data = in->i_buffer;
559 for( unsigned i_packet = 0; i_data > 0; i_packet++ )
561 size_t i_payload = i_data;
563 /* Make sure we stop on an UTF-8 character boundary
564 * (assuming the input is valid UTF-8) */
569 while( ( p_data[i_payload] & 0xC0 ) == 0x80 )
572 return VLC_SUCCESS; /* fishy input! */
578 block_t *out = block_Alloc( 12 + i_payload );
582 rtp_packetize_common( id, out, 0, in->i_pts + i_packet );
583 memcpy( out->p_buffer + 12, p_data, i_payload );
585 out->i_buffer = 12 + i_payload;
586 out->i_dts = out->i_pts;
589 rtp_packetize_send( id, out );
599 int rtp_packetize_spx( sout_stream_id_t *id, block_t *in )
601 uint8_t *p_buffer = in->p_buffer;
602 int i_data_size, i_payload_size, i_payload_padding;
603 i_data_size = i_payload_size = in->i_buffer;
604 i_payload_padding = 0;
607 if ( in->i_buffer > rtp_mtu (id) )
611 RFC for Speex in RTP says that each packet must end on an octet
612 boundary. So, we check to see if the number of bytes % 4 is zero.
613 If not, we have to add some padding.
615 This MAY be overkill since packetization is handled elsewhere and
616 appears to ensure the octet boundary. However, better safe than
619 if ( i_payload_size % 4 )
621 i_payload_padding = 4 - ( i_payload_size % 4 );
622 i_payload_size += i_payload_padding;
626 Allocate a new RTP p_output block of the appropriate size.
627 Allow for 12 extra bytes of RTP header.
629 p_out = block_Alloc( 12 + i_payload_size );
631 if ( i_payload_padding )
634 The padding is required to be a zero followed by all 1s.
636 char c_first_pad, c_remaining_pad;
638 c_remaining_pad = 0xFF;
641 Allow for 12 bytes before the i_data_size because
642 of the expected RTP header added during
643 rtp_packetize_common.
645 p_out->p_buffer[12 + i_data_size] = c_first_pad;
646 switch (i_payload_padding)
649 p_out->p_buffer[12 + i_data_size + 1] = c_remaining_pad;
652 p_out->p_buffer[12 + i_data_size + 1] = c_remaining_pad;
653 p_out->p_buffer[12 + i_data_size + 2] = c_remaining_pad;
658 /* Add the RTP header to our p_output buffer. */
659 rtp_packetize_common( id, p_out, 0, (in->i_pts > 0 ? in->i_pts : in->i_dts) );
660 /* Copy the Speex payload to the p_output buffer */
661 memcpy( &p_out->p_buffer[12], p_buffer, i_data_size );
663 p_out->i_buffer = 12 + i_payload_size;
664 p_out->i_dts = in->i_dts;
665 p_out->i_length = in->i_length;
667 /* Queue the buffer for actual transmission. */
668 rtp_packetize_send( id, p_out );