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 *****************************************************************************/
31 #include <vlc_block.h>
36 rtp_packetize_h264_nal( sout_stream_t *p_stream, sout_stream_id_t *id,
37 const uint8_t *p_data, int i_data, int64_t i_pts,
38 int64_t i_dts, vlc_bool_t b_last, int64_t i_length );
40 int rtp_packetize_mpa( sout_stream_t *p_stream, 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_New( p_stream, 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_t *p_stream, sout_stream_id_t *id,
82 int i_max = rtp_mtu (id) - 4; /* payload max in one packet */
83 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
85 uint8_t *p_data = in->p_buffer;
86 int i_data = in->i_buffer;
88 int b_sequence_start = 0;
89 int i_temporal_ref = 0;
90 int i_picture_coding_type = 0;
91 int i_fbv = 0, i_bfc = 0, i_ffv = 0, i_ffc = 0;
92 int b_start_slice = 0;
94 /* preparse this packet to get some info */
95 if( in->i_buffer > 4 )
98 int i_rest = in->i_buffer;
103 ( p[0] != 0x00 || p[1] != 0x00 || p[2] != 0x01 ) )
117 /* sequence start code */
118 b_sequence_start = 1;
120 else if( *p == 0x00 && i_rest >= 4 )
123 i_temporal_ref = ( p[1] << 2) |((p[2]>>6)&0x03);
124 i_picture_coding_type = (p[2] >> 3)&0x07;
126 if( i_rest >= 4 && ( i_picture_coding_type == 2 ||
127 i_picture_coding_type == 3 ) )
129 i_ffv = (p[3] >> 2)&0x01;
130 i_ffc = ((p[3]&0x03) << 1)|((p[4]>>7)&0x01);
131 if( i_rest > 4 && i_picture_coding_type == 3 )
133 i_fbv = (p[4]>>6)&0x01;
134 i_bfc = (p[4]>>3)&0x07;
138 else if( *p <= 0xaf )
145 for( i = 0; i < i_count; i++ )
147 int i_payload = __MIN( i_max, i_data );
148 block_t *out = block_New( p_stream,
150 uint32_t h = ( i_temporal_ref << 16 )|
151 ( b_sequence_start << 13 )|
152 ( b_start_slice << 12 )|
153 ( i == i_count - 1 ? 1 << 11 : 0 )|
154 ( i_picture_coding_type << 8 )|
155 ( i_fbv << 7 )|( i_bfc << 4 )|( i_ffv << 3 )|i_ffc;
157 /* rtp common header */
158 rtp_packetize_common( id, out, (i == i_count - 1)?1:0,
159 in->i_pts > 0 ? in->i_pts : in->i_dts );
161 /* 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 */
162 out->p_buffer[12] = ( h >> 24 )&0xff;
163 out->p_buffer[13] = ( h >> 16 )&0xff;
164 out->p_buffer[14] = ( h >> 8 )&0xff;
165 out->p_buffer[15] = ( h )&0xff;
167 memcpy( &out->p_buffer[16], p_data, i_payload );
169 out->i_buffer = 16 + i_payload;
170 out->i_dts = in->i_dts + i * in->i_length / i_count;
171 out->i_length = in->i_length / i_count;
173 rtp_packetize_send( id, out );
182 int rtp_packetize_ac3( sout_stream_t *p_stream, sout_stream_id_t *id,
185 int i_max = rtp_mtu (id) - 2; /* payload max in one packet */
186 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
188 uint8_t *p_data = in->p_buffer;
189 int i_data = in->i_buffer;
192 for( i = 0; i < i_count; i++ )
194 int i_payload = __MIN( i_max, i_data );
195 block_t *out = block_New( p_stream, 14 + i_payload );
197 /* rtp common header */
198 rtp_packetize_common( id, out, (i == i_count - 1)?1:0, in->i_pts );
200 out->p_buffer[12] = 1;
202 out->p_buffer[13] = 0x00;
204 memcpy( &out->p_buffer[14], p_data, i_payload );
206 out->i_buffer = 14 + i_payload;
207 out->i_dts = in->i_dts + i * in->i_length / i_count;
208 out->i_length = in->i_length / i_count;
210 rtp_packetize_send( id, out );
219 int rtp_packetize_split( sout_stream_t *p_stream, sout_stream_id_t *id,
222 int i_max = rtp_mtu (id); /* payload max in one packet */
223 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
225 uint8_t *p_data = in->p_buffer;
226 int i_data = in->i_buffer;
229 for( i = 0; i < i_count; i++ )
231 int i_payload = __MIN( i_max, i_data );
232 block_t *out = block_New( p_stream, 12 + i_payload );
234 /* rtp common header */
235 rtp_packetize_common( id, out, (i == i_count - 1),
236 (in->i_pts > 0 ? in->i_pts : in->i_dts) );
237 memcpy( &out->p_buffer[12], p_data, i_payload );
239 out->i_buffer = 12 + i_payload;
240 out->i_dts = in->i_dts + i * in->i_length / i_count;
241 out->i_length = in->i_length / i_count;
243 rtp_packetize_send( id, out );
253 int rtp_packetize_mp4a_latm( sout_stream_t *p_stream, sout_stream_id_t *id,
256 int i_max = rtp_mtu (id) - 2; /* payload max in one packet */
257 int latmhdrsize = in->i_buffer / 0xff + 1;
258 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
260 uint8_t *p_data = in->p_buffer, *p_header = NULL;
261 int i_data = in->i_buffer;
264 for( i = 0; i < i_count; i++ )
266 int i_payload = __MIN( i_max, i_data );
271 out = block_New( p_stream, 12 + latmhdrsize + i_payload );
273 /* rtp common header */
274 rtp_packetize_common( id, out, ((i == i_count - 1) ? 1 : 0),
275 (in->i_pts > 0 ? in->i_pts : in->i_dts) );
279 int tmp = in->i_buffer;
281 p_header=out->p_buffer+12;
291 memcpy( &out->p_buffer[12+latmhdrsize], p_data, i_payload );
293 out->i_buffer = 12 + latmhdrsize + i_payload;
294 out->i_dts = in->i_dts + i * in->i_length / i_count;
295 out->i_length = in->i_length / i_count;
297 rtp_packetize_send( id, out );
306 int rtp_packetize_l16( sout_stream_t *p_stream, sout_stream_id_t *id,
309 const uint8_t *p_data = in->p_buffer;
310 size_t i_data = in->i_buffer;
311 size_t i_plen = 2 * rtp_plen (id, 20);
313 for( unsigned i_packet = 0; i_data > 0; i_packet++ )
315 int i_payload = __MIN( i_plen, i_data );
316 block_t *out = block_New( p_stream, 12 + i_payload );
318 /* rtp common header */
319 rtp_packetize_common( id, out, 0,
320 (in->i_pts > 0 ? in->i_pts : in->i_dts) );
321 memcpy( &out->p_buffer[12], p_data, i_payload );
323 out->i_buffer = 12 + i_payload;
324 out->i_dts = in->i_dts + i_packet * 20000;
325 out->i_length = i_payload * 20000 / i_plen;
327 rtp_packetize_send( id, out );
336 int rtp_packetize_l8( sout_stream_t *p_stream, sout_stream_id_t *id,
339 const uint8_t *p_data = in->p_buffer;
340 size_t i_data = in->i_buffer;
341 size_t i_plen = rtp_plen (id, 20);
343 for( unsigned i_packet = 0; i_data > 0; i_packet++ )
345 int i_payload = __MIN( i_plen, i_data );
346 block_t *out = block_New( p_stream, 12 + i_payload );
348 /* rtp common header */
349 rtp_packetize_common( id, out, 0,
350 (in->i_pts > 0 ? in->i_pts : in->i_dts) );
351 memcpy( &out->p_buffer[12], p_data, i_payload );
353 out->i_buffer = 12 + i_payload;
354 out->i_dts = in->i_dts + i_packet * 20000;
355 out->i_length = i_payload * 20000 / i_plen;
357 rtp_packetize_send( id, out );
366 int rtp_packetize_mp4a( sout_stream_t *p_stream, sout_stream_id_t *id,
369 int i_max = rtp_mtu (id) - 4; /* payload max in one packet */
370 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
372 uint8_t *p_data = in->p_buffer;
373 int i_data = in->i_buffer;
376 for( i = 0; i < i_count; i++ )
378 int i_payload = __MIN( i_max, i_data );
379 block_t *out = block_New( p_stream, 16 + i_payload );
381 /* rtp common header */
382 rtp_packetize_common( id, out, ((i == i_count - 1)?1:0),
383 (in->i_pts > 0 ? in->i_pts : in->i_dts) );
385 /* AU headers length (bits) */
386 out->p_buffer[12] = 0;
387 out->p_buffer[13] = 2*8;
388 /* for each AU length 13 bits + idx 3bits, */
389 out->p_buffer[14] = ( in->i_buffer >> 5 )&0xff;
390 out->p_buffer[15] = ( (in->i_buffer&0xff)<<3 )|0;
392 memcpy( &out->p_buffer[16], p_data, i_payload );
394 out->i_buffer = 16 + i_payload;
395 out->i_dts = in->i_dts + i * in->i_length / i_count;
396 out->i_length = in->i_length / i_count;
398 rtp_packetize_send( id, out );
409 #define RTP_H263_HEADER_SIZE (2) // plen = 0
410 #define RTP_H263_PAYLOAD_START (14) // plen = 0
411 int rtp_packetize_h263( sout_stream_t *p_stream, sout_stream_id_t *id,
414 uint8_t *p_data = in->p_buffer;
415 int i_data = in->i_buffer;
417 int i_max = rtp_mtu (id) - RTP_H263_HEADER_SIZE; /* payload max in one packet */
420 int b_v_bit = 0; // no pesky error resilience
421 int i_plen = 0; // normally plen=0 for PSC packet
422 int i_pebit = 0; // because plen=0
429 if( p_data[0] || p_data[1] )
433 /* remove 2 leading 0 bytes */
436 i_count = ( i_data + i_max - 1 ) / i_max;
438 for( i = 0; i < i_count; i++ )
440 int i_payload = __MIN( i_max, i_data );
441 block_t *out = block_New( p_stream,
442 RTP_H263_PAYLOAD_START + i_payload );
443 b_p_bit = (i == 0) ? 1 : 0;
444 h = ( b_p_bit << 10 )|
449 /* rtp common header */
450 //b_m_bit = 1; // always contains end of frame
451 rtp_packetize_common( id, out, (i == i_count - 1)?1:0,
452 in->i_pts > 0 ? in->i_pts : in->i_dts );
455 out->p_buffer[12] = ( h >> 8 )&0xff;
456 out->p_buffer[13] = ( h )&0xff;
457 memcpy( &out->p_buffer[RTP_H263_PAYLOAD_START], p_data, i_payload );
459 out->i_buffer = RTP_H263_PAYLOAD_START + i_payload;
460 out->i_dts = in->i_dts + i * in->i_length / i_count;
461 out->i_length = in->i_length / i_count;
463 rtp_packetize_send( id, out );
474 rtp_packetize_h264_nal( sout_stream_t *p_stream, sout_stream_id_t *id,
475 const uint8_t *p_data, int i_data, int64_t i_pts,
476 int64_t i_dts, vlc_bool_t b_last, int64_t i_length )
478 const int i_max = rtp_mtu (id); /* payload max in one packet */
485 i_nal_hdr = p_data[3];
486 i_nal_type = i_nal_hdr&0x1f;
488 /* Skip start code */
493 if( i_data <= i_max )
495 /* Single NAL unit packet */
496 block_t *out = block_New( p_stream, 12 + i_data );
498 out->i_length = i_length;
501 rtp_packetize_common( id, out, b_last, i_pts );
502 out->i_buffer = 12 + i_data;
504 memcpy( &out->p_buffer[12], p_data, i_data );
506 rtp_packetize_send( id, out );
510 /* FU-A Fragmentation Unit without interleaving */
511 const int i_count = ( i_data-1 + i_max-2 - 1 ) / (i_max-2);
517 for( i = 0; i < i_count; i++ )
519 const int i_payload = __MIN( i_data, i_max-2 );
520 block_t *out = block_New( p_stream, 12 + 2 + i_payload );
521 out->i_dts = i_dts + i * i_length / i_count;
522 out->i_length = i_length / i_count;
525 rtp_packetize_common( id, out, (b_last && i_payload == i_data), i_pts );
526 out->i_buffer = 14 + i_payload;
529 out->p_buffer[12] = 0x00 | (i_nal_hdr & 0x60) | 28;
531 out->p_buffer[13] = ( i == 0 ? 0x80 : 0x00 ) | ( (i == i_count-1) ? 0x40 : 0x00 ) | i_nal_type;
532 memcpy( &out->p_buffer[14], p_data, i_payload );
534 rtp_packetize_send( id, out );
543 int rtp_packetize_h264( sout_stream_t *p_stream, sout_stream_id_t *id,
546 const uint8_t *p_buffer = in->p_buffer;
547 int i_buffer = in->i_buffer;
549 while( i_buffer > 4 && ( p_buffer[0] != 0 || p_buffer[1] != 0 || p_buffer[2] != 1 ) )
555 /* Split nal units */
556 while( i_buffer > 4 )
559 int i_size = i_buffer;
560 int i_skip = i_buffer;
563 for( i_offset = 4; i_offset+2 < i_buffer ; i_offset++)
565 if( p_buffer[i_offset] == 0 && p_buffer[i_offset+1] == 0 && p_buffer[i_offset+2] == 1 )
567 /* we found another startcode */
568 i_size = i_offset - ( p_buffer[i_offset-1] == 0 ? 1 : 0);
573 /* TODO add STAP-A to remove a lot of overhead with small slice/sei/... */
574 rtp_packetize_h264_nal( p_stream, id, p_buffer, i_size,
575 (in->i_pts > 0 ? in->i_pts : in->i_dts), in->i_dts,
576 (i_size >= i_buffer), in->i_length * i_size / in->i_buffer );
584 int rtp_packetize_amr( sout_stream_t *p_stream, sout_stream_id_t *id,
587 int i_max = rtp_mtu (id) - 2; /* payload max in one packet */
588 int i_count = ( in->i_buffer + i_max - 1 ) / i_max;
590 uint8_t *p_data = in->p_buffer;
591 int i_data = in->i_buffer;
594 /* Only supports octet-aligned mode */
595 for( i = 0; i < i_count; i++ )
597 int i_payload = __MIN( i_max, i_data );
598 block_t *out = block_New( p_stream, 14 + i_payload );
600 /* rtp common header */
601 rtp_packetize_common( id, out, ((i == i_count - 1)?1:0),
602 (in->i_pts > 0 ? in->i_pts : in->i_dts) );
604 out->p_buffer[12] = 0xF0; /* CMR */
605 out->p_buffer[13] = p_data[0]&0x7C; /* ToC */ /* FIXME: frame type */
607 /* FIXME: are we fed multiple frames ? */
608 memcpy( &out->p_buffer[14], p_data+1, i_payload-1 );
610 out->i_buffer = 14 + i_payload-1;
611 out->i_dts = in->i_dts + i * in->i_length / i_count;
612 out->i_length = in->i_length / i_count;
614 rtp_packetize_send( id, out );
623 int rtp_packetize_t140( sout_stream_t *p_stream, sout_stream_id_t *id,
626 const size_t i_max = rtp_mtu (id);
627 const uint8_t *p_data = in->p_buffer;
628 size_t i_data = in->i_buffer;
630 for( unsigned i_packet = 0; i_data > 0; i_packet++ )
632 size_t i_payload = i_data;
634 /* Make sure we stop on an UTF-8 character boundary
635 * (assuming the input is valid UTF-8) */
640 while( ( p_data[i_payload] & 0xC0 ) == 0x80 )
643 return VLC_SUCCESS; /* fishy input! */
649 block_t *out = block_New( p_stream, 12 + i_payload );
653 rtp_packetize_common( id, out, 0, in->i_pts + i_packet );
654 memcpy( out->p_buffer + 12, p_data, i_payload );
656 out->i_buffer = 12 + i_payload;
657 out->i_dts = out->i_pts;
660 rtp_packetize_send( id, out );
670 int rtp_packetize_spx( sout_stream_t *p_stream, sout_stream_id_t *id,
673 uint8_t *p_buffer = in->p_buffer;
674 int i_data_size, i_payload_size, i_payload_padding;
675 i_data_size = i_payload_size = in->i_buffer;
676 i_payload_padding = 0;
679 if ( in->i_buffer > rtp_mtu (id) )
681 msg_Warn( p_stream, "Cannot send packet larger than output MTU" );
686 RFC for Speex in RTP says that each packet must end on an octet
687 boundary. So, we check to see if the number of bytes % 4 is zero.
688 If not, we have to add some padding.
690 This MAY be overkill since packetization is handled elsewhere and
691 appears to ensure the octet boundary. However, better safe than
694 if ( i_payload_size % 4 )
696 i_payload_padding = 4 - ( i_payload_size % 4 );
697 i_payload_size += i_payload_padding;
701 Allocate a new RTP p_output block of the appropriate size.
702 Allow for 12 extra bytes of RTP header.
704 p_out = block_New( p_stream, 12 + i_payload_size );
706 if ( i_payload_padding )
709 The padding is required to be a zero followed by all 1s.
711 char c_first_pad, c_remaining_pad;
713 c_remaining_pad = 0xFF;
716 Allow for 12 bytes before the i_data_size because
717 of the expected RTP header added during
718 rtp_packetize_common.
720 p_out->p_buffer[12 + i_data_size] = c_first_pad;
721 switch (i_payload_padding)
724 p_out->p_buffer[12 + i_data_size + 1] = c_remaining_pad;
727 p_out->p_buffer[12 + i_data_size + 1] = c_remaining_pad;
728 p_out->p_buffer[12 + i_data_size + 2] = c_remaining_pad;
733 /* Add the RTP header to our p_output buffer. */
734 rtp_packetize_common( id, p_out, 0, (in->i_pts > 0 ? in->i_pts : in->i_dts) );
735 /* Copy the Speex payload to the p_output buffer */
736 memcpy( &p_out->p_buffer[12], p_buffer, i_data_size );
738 p_out->i_buffer = 12 + i_payload_size;
739 p_out->i_dts = in->i_dts;
740 p_out->i_length = in->i_length;
742 /* Queue the buffer for actual transmission. */
743 rtp_packetize_send( id, p_out );