git.sesse.net Git - vlc/blob - modules/stream_out/rtpfmt.c

   1 /*****************************************************************************
   2  * rtpfmt.c: RTP payload formats
   3  *****************************************************************************
   4  * Copyright (C) 2003-2004 the VideoLAN team
   5  * Copyright © 2007 Rémi Denis-Courmont
   6  * $Id$
   7  *
   8  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   9  *
  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.
  14  *
  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.
  19  *
  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  *****************************************************************************/
  24
  25 #ifdef HAVE_CONFIG_H
  26 # include "config.h"
  27 #endif
  28
  29 #include <vlc_common.h>
  30 #include <vlc_sout.h>
  31 #include <vlc_block.h>
  32
  33 #include "rtp.h"
  34
  35 int
  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, bool b_last, int64_t i_length );
  39
  40 int rtp_packetize_mpa( sout_stream_t *p_stream, sout_stream_id_t *id,
  41                        block_t *in )
  42 {
  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;
  45
  46     uint8_t *p_data = in->p_buffer;
  47     int     i_data  = in->i_buffer;
  48     int     i;
  49
  50     for( i = 0; i < i_count; i++ )
  51     {
  52         int           i_payload = __MIN( i_max, i_data );
  53         block_t *out = block_Alloc( 16 + i_payload );
  54
  55         /* rtp common header */
  56         rtp_packetize_common( id, out, (i == i_count - 1)?1:0, in->i_pts );
  57         /* mbz set to 0 */
  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 );
  64
  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;
  68
  69         rtp_packetize_send( id, out );
  70
  71         p_data += i_payload;
  72         i_data -= i_payload;
  73     }
  74
  75     return VLC_SUCCESS;
  76 }
  77
  78 /* rfc2250 */
  79 int rtp_packetize_mpv( sout_stream_t *p_stream, sout_stream_id_t *id,
  80                        block_t *in )
  81 {
  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;
  84
  85     uint8_t *p_data = in->p_buffer;
  86     int     i_data  = in->i_buffer;
  87     int     i;
  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;
  93
  94     /* preparse this packet to get some info */
  95     if( in->i_buffer > 4 )
  96     {
  97         uint8_t *p = p_data;
  98         int      i_rest = in->i_buffer;
  99
 100         for( ;; )
 101         {
 102             while( i_rest > 4 &&
 103                    ( p[0] != 0x00 || p[1] != 0x00 || p[2] != 0x01 ) )
 104             {
 105                 p++;
 106                 i_rest--;
 107             }
 108             if( i_rest <= 4 )
 109             {
 110                 break;
 111             }
 112             p += 3;
 113             i_rest -= 4;
 114
 115             if( *p == 0xb3 )
 116             {
 117                 /* sequence start code */
 118                 b_sequence_start = 1;
 119             }
 120             else if( *p == 0x00 && i_rest >= 4 )
 121             {
 122                 /* picture */
 123                 i_temporal_ref = ( p[1] << 2) |((p[2]>>6)&0x03);
 124                 i_picture_coding_type = (p[2] >> 3)&0x07;
 125
 126                 if( i_rest >= 4 && ( i_picture_coding_type == 2 ||
 127                                     i_picture_coding_type == 3 ) )
 128                 {
 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 )
 132                     {
 133                         i_fbv = (p[4]>>6)&0x01;
 134                         i_bfc = (p[4]>>3)&0x07;
 135                     }
 136                 }
 137             }
 138             else if( *p <= 0xaf )
 139             {
 140                 b_start_slice = 1;
 141             }
 142         }
 143     }
 144
 145     for( i = 0; i < i_count; i++ )
 146     {
 147         int           i_payload = __MIN( i_max, i_data );
 148         block_t *out = block_Alloc( 16 + i_payload );
 149         uint32_t      h = ( i_temporal_ref << 16 )|
 150                           ( b_sequence_start << 13 )|
 151                           ( b_start_slice << 12 )|
 152                           ( i == i_count - 1 ? 1 << 11 : 0 )|
 153                           ( i_picture_coding_type << 8 )|
 154                           ( i_fbv << 7 )|( i_bfc << 4 )|( i_ffv << 3 )|i_ffc;
 155
 156         /* rtp common header */
 157         rtp_packetize_common( id, out, (i == i_count - 1)?1:0,
 158                               in->i_pts > 0 ? in->i_pts : in->i_dts );
 159
 160         /* 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 */
 161         out->p_buffer[12] = ( h >> 24 )&0xff;
 162         out->p_buffer[13] = ( h >> 16 )&0xff;
 163         out->p_buffer[14] = ( h >>  8 )&0xff;
 164         out->p_buffer[15] = ( h       )&0xff;
 165
 166         memcpy( &out->p_buffer[16], p_data, i_payload );
 167
 168         out->i_buffer   = 16 + i_payload;
 169         out->i_dts    = in->i_dts + i * in->i_length / i_count;
 170         out->i_length = in->i_length / i_count;
 171
 172         rtp_packetize_send( id, out );
 173
 174         p_data += i_payload;
 175         i_data -= i_payload;
 176     }
 177
 178     return VLC_SUCCESS;
 179 }
 180
 181 int rtp_packetize_ac3( sout_stream_t *p_stream, sout_stream_id_t *id,
 182                        block_t *in )
 183 {
 184     int     i_max   = rtp_mtu (id) - 2; /* payload max in one packet */
 185     int     i_count = ( in->i_buffer + i_max - 1 ) / i_max;
 186
 187     uint8_t *p_data = in->p_buffer;
 188     int     i_data  = in->i_buffer;
 189     int     i;
 190
 191     for( i = 0; i < i_count; i++ )
 192     {
 193         int           i_payload = __MIN( i_max, i_data );
 194         block_t *out = block_Alloc( 14 + i_payload );
 195
 196         /* rtp common header */
 197         rtp_packetize_common( id, out, (i == i_count - 1)?1:0, in->i_pts );
 198         /* unit count */
 199         out->p_buffer[12] = 1;
 200         /* unit header */
 201         out->p_buffer[13] = 0x00;
 202         /* data */
 203         memcpy( &out->p_buffer[14], p_data, i_payload );
 204
 205         out->i_buffer   = 14 + i_payload;
 206         out->i_dts    = in->i_dts + i * in->i_length / i_count;
 207         out->i_length = in->i_length / i_count;
 208
 209         rtp_packetize_send( id, out );
 210
 211         p_data += i_payload;
 212         i_data -= i_payload;
 213     }
 214
 215     return VLC_SUCCESS;
 216 }
 217
 218 int rtp_packetize_split( sout_stream_t *p_stream, sout_stream_id_t *id,
 219                          block_t *in )
 220 {
 221     int     i_max   = rtp_mtu (id); /* payload max in one packet */
 222     int     i_count = ( in->i_buffer + i_max - 1 ) / i_max;
 223
 224     uint8_t *p_data = in->p_buffer;
 225     int     i_data  = in->i_buffer;
 226     int     i;
 227
 228     for( i = 0; i < i_count; i++ )
 229     {
 230         int           i_payload = __MIN( i_max, i_data );
 231         block_t *out = block_Alloc( 12 + i_payload );
 232
 233         /* rtp common header */
 234         rtp_packetize_common( id, out, (i == i_count - 1),
 235                               (in->i_pts > 0 ? in->i_pts : in->i_dts) );
 236         memcpy( &out->p_buffer[12], p_data, i_payload );
 237
 238         out->i_buffer   = 12 + i_payload;
 239         out->i_dts    = in->i_dts + i * in->i_length / i_count;
 240         out->i_length = in->i_length / i_count;
 241
 242         rtp_packetize_send( id, out );
 243
 244         p_data += i_payload;
 245         i_data -= i_payload;
 246     }
 247
 248     return VLC_SUCCESS;
 249 }
 250
 251 /* rfc3016 */
 252 int rtp_packetize_mp4a_latm( sout_stream_t *p_stream, sout_stream_id_t *id,
 253                              block_t *in )
 254 {
 255     int     i_max   = rtp_mtu (id) - 2;              /* payload max in one packet */
 256     int     latmhdrsize = in->i_buffer / 0xff + 1;
 257     int     i_count = ( in->i_buffer + i_max - 1 ) / i_max;
 258
 259     uint8_t *p_data = in->p_buffer, *p_header = NULL;
 260     int     i_data  = in->i_buffer;
 261     int     i;
 262
 263     for( i = 0; i < i_count; i++ )
 264     {
 265         int     i_payload = __MIN( i_max, i_data );
 266         block_t *out;
 267
 268         if( i != 0 )
 269             latmhdrsize = 0;
 270         out = block_Alloc( 12 + latmhdrsize + i_payload );
 271
 272         /* rtp common header */
 273         rtp_packetize_common( id, out, ((i == i_count - 1) ? 1 : 0),
 274                               (in->i_pts > 0 ? in->i_pts : in->i_dts) );
 275
 276         if( i == 0 )
 277         {
 278             int tmp = in->i_buffer;
 279
 280             p_header=out->p_buffer+12;
 281             while( tmp > 0xfe )
 282             {
 283                 *p_header = 0xff;
 284                 p_header++;
 285                 tmp -= 0xff;
 286             }
 287             *p_header = tmp;
 288         }
 289
 290         memcpy( &out->p_buffer[12+latmhdrsize], p_data, i_payload );
 291
 292         out->i_buffer   = 12 + latmhdrsize + i_payload;
 293         out->i_dts    = in->i_dts + i * in->i_length / i_count;
 294         out->i_length = in->i_length / i_count;
 295
 296         rtp_packetize_send( id, out );
 297
 298         p_data += i_payload;
 299         i_data -= i_payload;
 300     }
 301
 302     return VLC_SUCCESS;
 303 }
 304
 305 int rtp_packetize_mp4a( sout_stream_t *p_stream, sout_stream_id_t *id,
 306                         block_t *in )
 307 {
 308     int     i_max   = rtp_mtu (id) - 4; /* payload max in one packet */
 309     int     i_count = ( in->i_buffer + i_max - 1 ) / i_max;
 310
 311     uint8_t *p_data = in->p_buffer;
 312     int     i_data  = in->i_buffer;
 313     int     i;
 314
 315     for( i = 0; i < i_count; i++ )
 316     {
 317         int           i_payload = __MIN( i_max, i_data );
 318         block_t *out = block_Alloc( 16 + i_payload );
 319
 320         /* rtp common header */
 321         rtp_packetize_common( id, out, ((i == i_count - 1)?1:0),
 322                               (in->i_pts > 0 ? in->i_pts : in->i_dts) );
 323         /* AU headers */
 324         /* AU headers length (bits) */
 325         out->p_buffer[12] = 0;
 326         out->p_buffer[13] = 2*8;
 327         /* for each AU length 13 bits + idx 3bits, */
 328         out->p_buffer[14] = ( in->i_buffer >> 5 )&0xff;
 329         out->p_buffer[15] = ( (in->i_buffer&0xff)<<3 )|0;
 330
 331         memcpy( &out->p_buffer[16], p_data, i_payload );
 332
 333         out->i_buffer   = 16 + i_payload;
 334         out->i_dts    = in->i_dts + i * in->i_length / i_count;
 335         out->i_length = in->i_length / i_count;
 336
 337         rtp_packetize_send( id, out );
 338
 339         p_data += i_payload;
 340         i_data -= i_payload;
 341     }
 342
 343     return VLC_SUCCESS;
 344 }
 345
 346
 347 /* rfc2429 */
 348 #define RTP_H263_HEADER_SIZE (2)  // plen = 0
 349 #define RTP_H263_PAYLOAD_START (14)  // plen = 0
 350 int rtp_packetize_h263( sout_stream_t *p_stream, sout_stream_id_t *id,
 351                         block_t *in )
 352 {
 353     uint8_t *p_data = in->p_buffer;
 354     int     i_data  = in->i_buffer;
 355     int     i;
 356     int     i_max   = rtp_mtu (id) - RTP_H263_HEADER_SIZE; /* payload max in one packet */
 357     int     i_count;
 358     int     b_p_bit;
 359     int     b_v_bit = 0; // no pesky error resilience
 360     int     i_plen = 0; // normally plen=0 for PSC packet
 361     int     i_pebit = 0; // because plen=0
 362     uint16_t h;
 363
 364     if( i_data < 2 )
 365     {
 366         return VLC_EGENERIC;
 367     }
 368     if( p_data[0] || p_data[1] )
 369     {
 370         return VLC_EGENERIC;
 371     }
 372     /* remove 2 leading 0 bytes */
 373     p_data += 2;
 374     i_data -= 2;
 375     i_count = ( i_data + i_max - 1 ) / i_max;
 376
 377     for( i = 0; i < i_count; i++ )
 378     {
 379         int      i_payload = __MIN( i_max, i_data );
 380         block_t *out = block_Alloc( RTP_H263_PAYLOAD_START + i_payload );
 381         b_p_bit = (i == 0) ? 1 : 0;
 382         h = ( b_p_bit << 10 )|
 383             ( b_v_bit << 9  )|
 384             ( i_plen  << 3  )|
 385               i_pebit;
 386
 387         /* rtp common header */
 388         //b_m_bit = 1; // always contains end of frame
 389         rtp_packetize_common( id, out, (i == i_count - 1)?1:0,
 390                               in->i_pts > 0 ? in->i_pts : in->i_dts );
 391
 392         /* h263 header */
 393         out->p_buffer[12] = ( h >>  8 )&0xff;
 394         out->p_buffer[13] = ( h       )&0xff;
 395         memcpy( &out->p_buffer[RTP_H263_PAYLOAD_START], p_data, i_payload );
 396
 397         out->i_buffer = RTP_H263_PAYLOAD_START + i_payload;
 398         out->i_dts    = in->i_dts + i * in->i_length / i_count;
 399         out->i_length = in->i_length / i_count;
 400
 401         rtp_packetize_send( id, out );
 402
 403         p_data += i_payload;
 404         i_data -= i_payload;
 405     }
 406
 407     return VLC_SUCCESS;
 408 }
 409
 410 /* rfc3984 */
 411 int
 412 rtp_packetize_h264_nal( sout_stream_t *p_stream, sout_stream_id_t *id,
 413                         const uint8_t *p_data, int i_data, int64_t i_pts,
 414                         int64_t i_dts, bool b_last, int64_t i_length )
 415 {
 416     const int i_max = rtp_mtu (id); /* payload max in one packet */
 417     int i_nal_hdr;
 418     int i_nal_type;
 419
 420     if( i_data < 5 )
 421         return VLC_SUCCESS;
 422
 423     i_nal_hdr = p_data[3];
 424     i_nal_type = i_nal_hdr&0x1f;
 425
 426     /* Skip start code */
 427     p_data += 3;
 428     i_data -= 3;
 429
 430     /* */
 431     if( i_data <= i_max )
 432     {
 433         /* Single NAL unit packet */
 434         block_t *out = block_Alloc( 12 + i_data );
 435         out->i_dts    = i_dts;
 436         out->i_length = i_length;
 437
 438         /* */
 439         rtp_packetize_common( id, out, b_last, i_pts );
 440         out->i_buffer = 12 + i_data;
 441
 442         memcpy( &out->p_buffer[12], p_data, i_data );
 443
 444         rtp_packetize_send( id, out );
 445     }
 446     else
 447     {
 448         /* FU-A Fragmentation Unit without interleaving */
 449         const int i_count = ( i_data-1 + i_max-2 - 1 ) / (i_max-2);
 450         int i;
 451
 452         p_data++;
 453         i_data--;
 454
 455         for( i = 0; i < i_count; i++ )
 456         {
 457             const int i_payload = __MIN( i_data, i_max-2 );
 458             block_t *out = block_Alloc( 12 + 2 + i_payload );
 459             out->i_dts    = i_dts + i * i_length / i_count;
 460             out->i_length = i_length / i_count;
 461
 462             /* */
 463             rtp_packetize_common( id, out, (b_last && i_payload == i_data), i_pts );
 464             out->i_buffer = 14 + i_payload;
 465
 466             /* FU indicator */
 467             out->p_buffer[12] = 0x00 | (i_nal_hdr & 0x60) | 28;
 468             /* FU header */
 469             out->p_buffer[13] = ( i == 0 ? 0x80 : 0x00 ) | ( (i == i_count-1) ? 0x40 : 0x00 )  | i_nal_type;
 470             memcpy( &out->p_buffer[14], p_data, i_payload );
 471
 472             rtp_packetize_send( id, out );
 473
 474             i_data -= i_payload;
 475             p_data += i_payload;
 476         }
 477     }
 478     return VLC_SUCCESS;
 479 }
 480
 481 int rtp_packetize_h264( sout_stream_t *p_stream, sout_stream_id_t *id,
 482                         block_t *in )
 483 {
 484     const uint8_t *p_buffer = in->p_buffer;
 485     int i_buffer = in->i_buffer;
 486
 487     while( i_buffer > 4 && ( p_buffer[0] != 0 || p_buffer[1] != 0 || p_buffer[2] != 1 ) )
 488     {
 489         i_buffer--;
 490         p_buffer++;
 491     }
 492
 493     /* Split nal units */
 494     while( i_buffer > 4 )
 495     {
 496         int i_offset;
 497         int i_size = i_buffer;
 498         int i_skip = i_buffer;
 499
 500         /* search nal end */
 501         for( i_offset = 4; i_offset+2 < i_buffer ; i_offset++)
 502         {
 503             if( p_buffer[i_offset] == 0 && p_buffer[i_offset+1] == 0 && p_buffer[i_offset+2] == 1 )
 504             {
 505                 /* we found another startcode */
 506                 i_size = i_offset - ( p_buffer[i_offset-1] == 0 ? 1 : 0);
 507                 i_skip = i_offset;
 508                 break;
 509             }
 510         }
 511         /* TODO add STAP-A to remove a lot of overhead with small slice/sei/... */
 512         rtp_packetize_h264_nal( p_stream, id, p_buffer, i_size,
 513                                 (in->i_pts > 0 ? in->i_pts : in->i_dts), in->i_dts,
 514                                 (i_size >= i_buffer), in->i_length * i_size / in->i_buffer );
 515
 516         i_buffer -= i_skip;
 517         p_buffer += i_skip;
 518     }
 519     return VLC_SUCCESS;
 520 }
 521
 522 int rtp_packetize_amr( sout_stream_t *p_stream, sout_stream_id_t *id,
 523                        block_t *in )
 524 {
 525     int     i_max   = rtp_mtu (id) - 2; /* payload max in one packet */
 526     int     i_count = ( in->i_buffer + i_max - 1 ) / i_max;
 527
 528     uint8_t *p_data = in->p_buffer;
 529     int     i_data  = in->i_buffer;
 530     int     i;
 531
 532     /* Only supports octet-aligned mode */
 533     for( i = 0; i < i_count; i++ )
 534     {
 535         int           i_payload = __MIN( i_max, i_data );
 536         block_t *out = block_Alloc( 14 + i_payload );
 537
 538         /* rtp common header */
 539         rtp_packetize_common( id, out, ((i == i_count - 1)?1:0),
 540                               (in->i_pts > 0 ? in->i_pts : in->i_dts) );
 541         /* Payload header */
 542         out->p_buffer[12] = 0xF0; /* CMR */
 543         out->p_buffer[13] = p_data[0]&0x7C; /* ToC */ /* FIXME: frame type */
 544
 545         /* FIXME: are we fed multiple frames ? */
 546         memcpy( &out->p_buffer[14], p_data+1, i_payload-1 );
 547
 548         out->i_buffer   = 14 + i_payload-1;
 549         out->i_dts    = in->i_dts + i * in->i_length / i_count;
 550         out->i_length = in->i_length / i_count;
 551
 552         rtp_packetize_send( id, out );
 553
 554         p_data += i_payload;
 555         i_data -= i_payload;
 556     }
 557
 558     return VLC_SUCCESS;
 559 }
 560
 561 int rtp_packetize_t140( sout_stream_t *p_stream, sout_stream_id_t *id,
 562                         block_t *in )
 563 {
 564     const size_t   i_max  = rtp_mtu (id);
 565     const uint8_t *p_data = in->p_buffer;
 566     size_t         i_data = in->i_buffer;
 567
 568     for( unsigned i_packet = 0; i_data > 0; i_packet++ )
 569     {
 570         size_t i_payload = i_data;
 571
 572         /* Make sure we stop on an UTF-8 character boundary
 573          * (assuming the input is valid UTF-8) */
 574         if( i_data > i_max )
 575         {
 576             i_payload = i_max;
 577
 578             while( ( p_data[i_payload] & 0xC0 ) == 0x80 )
 579             {
 580                 if( i_payload == 0 )
 581                     return VLC_SUCCESS; /* fishy input! */
 582
 583                 i_payload--;
 584             }
 585         }
 586
 587         block_t *out = block_Alloc( 12 + i_payload );
 588         if( out == NULL )
 589             return VLC_SUCCESS;
 590
 591         rtp_packetize_common( id, out, 0, in->i_pts + i_packet );
 592         memcpy( out->p_buffer + 12, p_data, i_payload );
 593
 594         out->i_buffer = 12 + i_payload;
 595         out->i_dts    = out->i_pts;
 596         out->i_length = 0;
 597
 598         rtp_packetize_send( id, out );
 599
 600         p_data += i_payload;
 601         i_data -= i_payload;
 602     }
 603
 604     return VLC_SUCCESS;
 605 }
 606
 607
 608 int rtp_packetize_spx( sout_stream_t *p_stream, sout_stream_id_t *id,
 609                        block_t *in )
 610 {
 611     uint8_t *p_buffer = in->p_buffer;
 612     int i_data_size, i_payload_size, i_payload_padding;
 613     i_data_size = i_payload_size = in->i_buffer;
 614     i_payload_padding = 0;
 615     block_t *p_out;
 616
 617     if ( in->i_buffer > rtp_mtu (id) )
 618     {
 619         msg_Warn( p_stream, "Cannot send packet larger than output MTU" );
 620         return VLC_SUCCESS;
 621     }
 622
 623     /*
 624       RFC for Speex in RTP says that each packet must end on an octet
 625       boundary. So, we check to see if the number of bytes % 4 is zero.
 626       If not, we have to add some padding.
 627
 628       This MAY be overkill since packetization is handled elsewhere and
 629       appears to ensure the octet boundary. However, better safe than
 630       sorry.
 631     */
 632     if ( i_payload_size % 4 )
 633     {
 634         i_payload_padding = 4 - ( i_payload_size % 4 );
 635         i_payload_size += i_payload_padding;
 636     }
 637
 638     /*
 639       Allocate a new RTP p_output block of the appropriate size.
 640       Allow for 12 extra bytes of RTP header.
 641     */
 642     p_out = block_Alloc( 12 + i_payload_size );
 643
 644     if ( i_payload_padding )
 645     {
 646     /*
 647       The padding is required to be a zero followed by all 1s.
 648     */
 649         char c_first_pad, c_remaining_pad;
 650         c_first_pad = 0x7F;
 651         c_remaining_pad = 0xFF;
 652
 653         /*
 654           Allow for 12 bytes before the i_data_size because
 655           of the expected RTP header added during
 656           rtp_packetize_common.
 657         */
 658         p_out->p_buffer[12 + i_data_size] = c_first_pad;
 659         switch (i_payload_padding)
 660         {
 661           case 2:
 662             p_out->p_buffer[12 + i_data_size + 1] = c_remaining_pad;
 663             break;
 664           case 3:
 665             p_out->p_buffer[12 + i_data_size + 1] = c_remaining_pad;
 666             p_out->p_buffer[12 + i_data_size + 2] = c_remaining_pad;
 667             break;
 668         }
 669     }
 670
 671     /* Add the RTP header to our p_output buffer. */
 672     rtp_packetize_common( id, p_out, 0, (in->i_pts > 0 ? in->i_pts : in->i_dts) );
 673     /* Copy the Speex payload to the p_output buffer */
 674     memcpy( &p_out->p_buffer[12], p_buffer, i_data_size );
 675
 676     p_out->i_buffer = 12 + i_payload_size;
 677     p_out->i_dts = in->i_dts;
 678     p_out->i_length = in->i_length;
 679
 680     /* Queue the buffer for actual transmission. */
 681     rtp_packetize_send( id, p_out );
 682     return VLC_SUCCESS;
 683 }