Abstract:
There have been proposals to extend the MPE protocol to support different FEC schemes on the MPE layer. Examples of these proposals include: TM-SSP0178 describing a multiburst sliding encoding scheme based on Reed-Solomon (RS) codes, TM-SSP0199r1 describing a block-based encoding scheme based on multi-stage chain reaction (MSCR) codes, and TM-SSP0222 describing a multiburst sliding encoding scheme based on MSCR codes. A framework for harmonizing and integrating those techniques is described herein.

Description:
CROSS-REFERENCES TO RELATED APPLICATIONS 
       [0001]    This application claims the benefit of U.S. Provisional Application No. 60/910,443 entitled “Sliding MPE-FEC Encoding With Multi-Stage Chain Reaction,” filed Apr. 5, 2007. This application also claims the benefit of U.S. Provisional Application No. 60/940,963 entitled “Protocol Extensions To Support Varying FEC Types,” filed May 30, 2007. The contents of these applications are herein incorporated by reference in their entirety for all purposes. 
     
    
     BACKGROUND OF THE INVENTION 
       [0002]    The present invention relates generally to data communications and in particular to forward error correction (FEC) coding. 
         [0003]    There are a number of ways to encode data with FEC over a unidirectional transport channel. For example, DVB SSP0178 describes “Multi Burst Sliding Encoding” (UDcast, February 2007). T. Paila, M. Luby, R. Lehtonen, V. Roca, R. Walsh, “FLUTE—File Delivery over Unidirectional Transport”, RFC 3926 (October 2004) provides some background on file delivery techniques. DVB-CBMS, “IP Datacast over DVB-H; Content Delivery Protocols (CDP)”, DVB Document A101 (December 2005), “PGM Reliable Transport Protocol Specification”, RFC 3208 (December 2001), and DVB documents TM-SSP0113, TM-SSP0149, and TM-SSP0184 provide more background information. 
       BRIEF SUMMARY OF THE INVENTION 
       [0004]    There have been a number of proposals to extend the MPE protocol to support different FEC schemes on the MPE layer. Examples of these proposals include: TM-SSP0178 describing a multiburst sliding encoding scheme based on Reed-Solomon (RS) codes, TM-SSP0199r1 describing a block-based encoding scheme based on multi-stage chain reaction (MSCR) codes, and TM-SSP0222 describing a multiburst sliding encoding scheme based on MSCR codes. A framework for harmonizing and integrating those techniques is described herein. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0005]      FIG. 1  shows an example of the FEC streaming framework architecture. 
       
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
       [0006]    1. Proposed Framework 
       1.1 Transmission Framework 
       [0007]    It is assumed that data is transmitted in logical units of bursts. Bursts can be logical transport bursts as in DVB-SH or can be “group of pictures” bursts in a video or both. A burst comprises individual packets generally having different lengths. The bursts also generally have variable length, but are bounded to a certain maximum number of bytes, referred to herein by “N B ”. 
         [0008]    The bursts should be transmitted unmodified to fulfill legacy constraints. Furthermore, the data bursts are transmitted in transport bursts whereby each transport burst contains exactly one data burst. 
         [0009]    Each transport burst and therefore each data burst are uniquely identifiable by a burst number i. However, the transport burst might contain, in addition to the data burst, some forward error correction (FEC) data, which relates to the data burst, such that losses of packets in the data bursts can be compensated. 
         [0010]    The repair data is sent in a similar format as the source data, but the header of the repair data allows the FEC data to be distinguished from the source data. 
       1.2 Parameters 
       [0011]    Below is an example of one set of parameters that can be used with this framework. 
         [0000]    
       
         
               
             
               
               
               
             
           
               
                 TABLE 1 
               
             
             
               
                   
               
               
                 Possible Parameters for Proposed Framework 
               
             
          
           
               
                 Parameter 
                 Description 
                 Range 
               
               
                   
               
               
                 F 
                 FEC Encoding Frequency (Data Bursts/SB) 
                 F = 1, . . . , tbd 
               
               
                 B 
                 FEC Data Interleaving 
                 B = F, 2F, 3F, . . . 
               
               
                 S 
                 FEC Spread 
                 S = F, 2F, 3F, . . . 
               
               
                 D 
                 Early sending of FEC, D = 0, FEC right after 
                 D = −tbd, . . . , 0, . . . , B, . . . 
               
               
                   
                 data, D = B, 
               
               
                 Cmax 
                 Maximum Number of Data Columns per Slice 
                 Cmax = 191 
               
               
                 C 
                 Number of Data Columns per Burst 
                 C = 0, . . . , Cmax 
               
               
                 R 
                 Number of Rows 
                 R = 256, 512, 768, 1024 
               
               
                 T 
                 Symbol Size 
                 T = 32, . . . , R (dividable by R) 
               
               
                 G 
                 Maximum number of symbols per section 
                 Gmax = 1, . . . , R/T 
               
               
                 M 
                 Concurrent source blocks 
                 M = 1, . . . 
               
               
                 N B   
                 Number of maximum bytes in data burst 
               
               
                 Kmax 
                 Maximum number of data symbols in source 
               
               
                   
                 block 
               
               
                 Nmax 
                 Maximum number of FEC symbols in source 
               
               
                   
                 block 
               
               
                   
               
             
          
         
       
     
         [0012]    To ensure that an encoder can always encode the source data, the data burst size should not exceed the total amount of available source symbols per burst, i.e., ceil(NB/T)≦floor(Kmax/F). 
       Initiliazation 
       [0013]    Assume that the encoder knows the total amount of concurrent source blocks, M, as well as the bursts being stored at the transmitter, X, and at the receiver, Y. These numbers can be either explicitly or implicitly provided. For the framework considered in one possible embodiment, the initialization process for the extended MPE-FEC is as set forth in the source code listing below: 
         [0000]    
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 /* Number of concurrent source blocks to be remembered at the 
               
               
                   
                       transmitter and receiver */ 
               
               
                   
                 M = (MAX(B−D, D−B)+S)/F; 
               
               
                   
                 /* How many data bursts do I have to store at the transmitter? */ 
               
               
                   
                 X = MAX(1, D); 
               
               
                   
                 /* How many data bursts do I have to remember at the receiver? */ 
               
               
                   
                 Y = MAX(B−D, D−B)+S+1; 
               
               
                   
                 /* Maximum Number of Symbols per Row */ 
               
               
                   
                 Gmax = R/T; 
               
               
                   
                   
               
             
          
         
       
     
       Encoder Definition 
       [0014]    In one embodiment of an encoder, during the encoder initialization, M concurrent source block matrices SB(0), . . . , SB(M−1) are allocated with each data matrix size Kmax*T to host the encoding. FEC symbols can generally be produced on-the-fly from the source data directly or for example an intermediate matrix only slightly larger than Kmax, so no explicit FEC matrix needs to be reserved. 
         [0015]    In this embodiment, assume the burst with burst number i is received. In that case, some processing is done. This processing can be done in a number of phases, such as a data processing phase, a FEC processing phase, a data transmission phase, and a FEC transmission phase. An example of each of these phases is described below. 
         [0016]    In the data processing phase, the encapsulation rules shown below can be applied for each section in burst i: 
         [0000]    
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 /* Section data */ 
               
               
                   
                 section_in-&gt;table_id = TABLE_ID; 
               
               
                   
                 ... 
               
               
                   
                 section_in-&gt;section_length = section_in-&gt;length; 
               
               
                   
                 /* Real-time parameters */ 
               
               
                   
                 section_in-&gt;address = burst[i]-&gt;address; 
               
               
                   
                 section_in-&gt;delta_t = ...; 
               
               
                   
                 burst[i]-&gt;address += section_in-&gt;upper_layer_PDU-&gt;size; 
               
               
                   
                   
               
             
          
         
       
     
         [0017]    Burst i is stored in the transmitter and sequentially inserted in the application data table of size Kmax/F×T, such that we have no_data_columns[i]=(burst[i]&gt;address+T−1)/T encoding symbols denoted as burst[i]→symbol[k]. 
         [0018]    Burst i is inserted in FEC environment as follows: 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                 /* define the number of the burst in the source block   */ 
               
               
                 burst_no_in_sb = i%F; 
               
               
                 /* define number of data columns in burst     */ 
               
               
                 no_data_columns[i] = (burst[i]-&gt; address + T − 1)/T; 
               
               
                 /* Where to start     */ 
               
               
                 int esi_start = burst_no_in_sb*(Kmax/F); 
               
               
                 for(int k=0; k&lt; no_data_columns[i]; k++) 
               
               
                 { 
               
               
                   m = get_data_queue_index(i, k+esi_start); 
               
               
                   /* insert column k−esi_start of burst b in matrix m */ 
               
               
                   SB[m]-&gt;column[fec_enc[m]-&gt;write_position] = burst[i]-&gt;symbol[k]; 
               
               
                   SB[m]-&gt;write_position++; 
               
               
                 } 
               
               
                 for(int k=no_data_columns[i]; k&lt;(Kmax/F); k++) 
               
               
                 { 
               
               
                   m = get_data_queue_index(i, k+esi_start); 
               
               
                   /* insert padding in matrix m */ 
               
               
                   SB[m]-&gt;column[fec_enc[m]-&gt;write_position] = 0; 
               
               
                   SB[m]-&gt;write_position++; 
               
               
                 } 
               
               
                   
               
             
          
         
       
     
         [0019]    In the FEC processing phase, assume a source block is completed and can be used to generate FEC symbols. An example of this is: 
         [0000]    
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 if(!((i+1)%F) ) 
               
               
                   
                 { 
               
               
                   
                   /* compute FEC for m=i%(B+S)     */ 
               
               
                   
                   int m = (i/F)%M; 
               
               
                   
                   prepare_to_generate_fec(SB[m]); 
               
               
                   
                   SB[m]-&gt;fecflag = TRUE; 
               
               
                   
                 } 
               
               
                   
                   
               
             
          
         
       
     
         [0020]    In the data transmission phase, the data sections in burst burst[j], j=max(i, i−D) are transmitted without any modifications. 
         [0021]    In the FEC transmission phase, the remaining size remaining data of the burst is used to fill it up with FEC. 
         [0000]    
       
         
               
             
               
               
             
               
               
             
               
             
               
               
             
           
               
                   
               
             
             
               
                 /* Determines the FEC section number*/ 
               
               
                 int fecsection = 0; 
               
               
                 /* Assume that we have space for at least one FEC section*/ 
               
               
                 section_in-&gt;frame_boundary = 0; 
               
               
                 while(!section_in-&gt;frame_boundary) 
               
               
                 { 
               
               
                   /* Section encapsulation - depends on FEC scheme*/ 
               
               
                   exmpe_fec_encapsulation(section_in, B, S, F, D, i, fecsection, 
               
               
                       no_data_columns); 
               
               
                   section_in-&gt;length = EXMPE_HEADERLENGTH+CRC32_LENGTH; 
               
               
                   /* Numbers section in burst       */ 
               
               
                   int m=get_fec_queue_index(i, fecsection); 
               
               
                   /* Numbers encoding symbol id of FEC*/ 
               
               
                   section_in-&gt;encoding_symbol_id = SB[m]-&gt;esi; 
               
               
                   /* Note: if this doesn&#39;t work, it can be altered or omitted */ 
               
               
                   section_in-&gt;prev_burst_size = fe-&gt;padding_esi[current_burst-&gt;burst_no%B]; 
               
               
                   for(int j=0; j&lt;Gmax &amp;&amp; SB[m]-&gt;esi &lt; Nmax; j++) 
               
               
                   { 
               
               
                     /* generate FEC data - depends on FEC scheme  */ 
               
               
                     symbol = generate_FEC_symbols(SB[m], SB[m]-&gt;esi); 
               
               
                     add_symbol_to_section_payload(symbol, section_in); 
               
               
                     /* get FEC column    fe-&gt;rs_data[current_burst-&gt;column] */ 
               
               
                     section_in-&gt;length += T; 
               
               
                     remaining_fec_data −= T; 
               
               
                     /* increase fec burst column */ 
               
               
                     SB[m]-&gt;esi++; 
               
               
                     /* Always check if there is still sufficient space in burst to add symbol 
               
               
                       */ 
               
               
                     if(remaining_fec_data &lt; T) 
               
               
                       break; 
               
               
                   } 
               
               
                   /* Is there still enough room for at least one symbol after we have added 
               
               
                       these symbols? */ 
               
               
                   if ( still_space_in_burst( ) &amp;&amp; SB[m]-&gt;esi &lt; Nmax ) 
               
               
                   { 
               
               
                     /* We can at least add one more symbol */ 
               
               
                     section_in-&gt;frame_boundary = 0; 
               
               
                   } 
               
               
                   else 
               
               
                   { 
               
               
                     /* That&#39;s it - last packet for this slice*/ 
               
               
                     section_in-&gt;frame_boundary = 1; 
               
             
          
           
               
                     /* Have completed an entire source block with FEC? 
                 */ 
               
               
                     if( !((i+1)%F) ) 
               
               
                     { 
               
             
          
           
               
                       /* Yes - completed 
                 */ 
               
             
          
           
               
                       /* Resetting necessary for the FEC block which is up next 
               
               
                         */ 
               
               
                       int m = get_data_queue_index(i+1, MAX(B, D+1)/F−1); 
               
               
                       /* Reset sourceblock */ 
               
               
                       /* Is this correct? */ 
               
               
                       SB[m]-&gt;fecflag = FALSE; 
               
               
                       SB[m]-&gt;esi = 0; 
               
               
                       /* reset padding esi */ 
               
               
                     } 
               
             
          
           
               
                     /* Reset current burst 
                 */ 
               
               
                     reset_burst(burst[i]); 
               
               
                   } 
               
               
                   create_section_crc(section_in) 
               
               
                 } 
               
               
                   
               
             
          
         
       
     
       Decoder Definition 
       [0022]    In one possible embodiment of the receiver, the received sections are inserted into the corresponding decoding blocks in the receiver. For this purpose, the decoder maintains M concurrent decoding block matrices DB(0), . . . , DB(M−1). For simplicity, assume an allocation for each decoding block a matrix of size Nmax*T to host the decoding information. In general only slightly larger memory size Kmax*T need be maintained to store the received encoding symbol IDs along with the ESI number. Indeed, only a size slightly larger than N B *F is sufficient for the decoding process. 
         [0023]    A possible decoder operation is presented below. With the complete reception of burst i, the burst is inserted into the FEC decoding blocks using the information provided in the header of the correct data sections and the correct FEC sections. For this purpose, the burst number and the mapping of burst number and section address to decoding blocks should to be known also at the receiver. 
         [0000]    
       
         
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
           
               
                   
               
             
             
               
                 /* Insert data section in fec decoding blocks 
                 */ 
               
               
                 insert_data_sections_in_fec_decoding_blocks(burst[i]); 
               
               
                 /* Insert FEC sections in fec decoding blocks 
                 */ 
               
               
                 insert_fec_sections_in_fec_decoding_block(burst[i]); 
               
               
                 /* collect the padding information for each burst  */ 
               
               
                 collect_padding_information(no_data_symbols, burst[i]); 
               
               
                 /* decode only one source block at this time  */ 
               
               
                 int m = get_data_queue_index(i+1, MAX(B, D+1)/F−1); 
               
               
                 /* decode only one source blockat this time  */ 
               
               
                 if(DB[m]-&gt;in_use &amp;&amp; !((i+1)%F) ) 
               
               
                 { 
               
             
          
           
               
                  /* Set decoding parameters 
                 */ 
               
               
                  DB[m]-&gt;sbl = Kmax; 
               
               
                  /* Before decoding, insert padding information 
                 */ 
               
               
                  insert_padding_information(no_data_symbols); 
               
               
                  /* Apply FEC decoding 
                 */ 
               
               
                  if( fec_decoding(DB[m]) ) 
               
               
                  { 
               
             
          
           
               
                   /* FEC decoding was successful 
                 */ 
               
               
                   DB[m]-&gt;ei_flag = FALSE; 
               
             
          
           
               
                   /* After decoding - update information in all bursts 
                 */ 
               
               
                   for(int j = i−Y+1; j&lt;=i; j++) 
               
               
                   { 
               
               
                    b = burst[(j+Y)%Y]; 
               
               
                    if(b-&gt;eiflag) 
               
               
                    { 
               
             
          
           
               
                     /* Copy recovered symbols to burst 
                 */ 
               
             
          
           
               
                     copy_symbols_to_burst(b, SB[m]); 
               
               
                     /* Try to recover burst  */ 
               
               
                     recover_burst(b); 
               
               
                     /* Note: early delivery of bursts would be possible here if 
               
               
                    b-&gt;eiflag = FALSE after recovery */ 
               
               
                    } 
               
               
                   } 
               
               
                  } 
               
             
          
           
               
                  /* Deliver all bursts in this FEC block 
                 */ 
               
               
                  for(int j = i−Y+1; j &lt;= (i−Y+F); j++) 
               
               
                  { 
               
               
                   deliver_burst(burst[j]); 
               
               
                   /* Reset burst */ 
               
               
                   reset_burst(burst[j]); 
               
               
                  } 
               
               
                  /* Reset decoding block 
                 */ 
               
               
                  reset_decoding_block(DB[m]); 
               
               
                 } 
               
               
                   
               
             
          
         
       
     
       Mapping Definition 
       [0024]    The mapping of burst and column numbers to data and FEC queue are defined below. One possible mapping is defined by: 
         [0000]    
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 int get_data_queue_index(int burst_number, int column_no) 
               
               
                   
                 { 
               
               
                   
                   return ( (burst_number)/F+column_no%(B/F))%M; 
               
               
                   
                 } 
               
               
                   
                   
               
             
          
         
       
     
         [0025]    The mapping can also be left open, if source block number and the column number are signaled explicitly. A possible inherent mapping is shown below. 
         [0000]    
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 int get_fec_queue_index(int burst_number, int column_no) 
               
               
                   
                 { 
               
               
                   
                   return ( (burst_number+D)/F−column_no%(S/F)−1)%M; 
               
               
                   
                 } 
               
               
                   
                   
               
             
          
         
       
     
       Carriage of Outer FEC Data 
       [0026]    The following provides an example of carrying outer FEC Data. In general, each MPE-OFEC section can carry an arbitrary number of the corresponding OFEC-FDT. The length of a column is indicated in field frame_size of the corresponding time_slice 13  fec_identifier descriptor, and the number of carried columns can be computed by the dividing the section length by the symbol length. 
         [0027]    The number of MPE-FEC sections used to carry OFEC data of and MPE-OFEC Frame should be limited to the number of columns of the OFEC-FDT. However, the number of MPE-OFEC sections delivered may be less, indicating that not all OFEC data is transmitted. In the latter case, the OFEC-decoder can consider bytes on columns not delivered as unreliable. 
         [0028]    The syntax and semantics of the MPE-OFEC_section are defined in Table 2. 
         [0000]    
       
         
               
             
               
               
               
             
               
               
               
             
           
               
                 TABLE 2 
               
             
             
               
                   
               
               
                 MPE-OFEC Section 
               
             
          
           
               
                 Syntax 
                 Number of bits 
                 Identifier 
               
               
                   
               
             
          
           
               
                 MPE-OFEC_section ( ){ 
                   
                   
               
               
                   table_id 
                 8 
                 uimsbf 
               
               
                   section_syntax_indicator 
                 1 
                 bslbf 
               
               
                   private_indicator 
                 1 
                 bslbf 
               
               
                   reserved 
                 2 
                 bslbf 
               
               
                   section_length 
                 12 
                 uimsbf 
               
               
                   FEC Scheme relevant information 
                 16-32 
                 uimsbf 
               
               
                   reserved_for_future_use 
                 7 
                 bslbf 
               
               
                   current_next_indicator 
                 1 
                 bslbf 
               
               
                   delta_t 
                 12 
                 uimsbf 
               
               
                   frame_boundary 
                 1 
                 bslbf 
               
               
                   table_boundary 
                 1 
                 bslbf 
               
               
                   padding_information 
                 18 
                 uimsbf 
               
               
                   for (i=0; i&lt;N; i++) { 
               
               
                     FEC_data_byte 
                 8 
                 uimsbf 
               
               
                   } 
               
               
                   CRC_32 
                 32 
                 uimsbf 
               
               
                 } 
               
               
                   
               
             
          
         
       
     
         [0029]    Here is a description of the elements listed in Table 2: 
         [0030]    table_id: The field is set to a predetermined value. 
         [0031]    section_syntax_indicator: This field is set to 1 and interpreted as in ISO/IEC 13818-6. 
         [0032]    private_indicator: This field is set to 0 and interpreted as defined by ISO/IEC 13818-6. 
         [0033]    reserved: This field is set to “11.” 
         [0034]    section_length: This field specifies the number of remaining bytes in the section immediately following this field up to the end of the section, including the CRC. 
         [0035]    reserved_for_future_use: These seven bits are set, when not used, to “1111111.” 
         [0036]    current_next indicator: This field is set to a value of “1.” 
         [0037]    Several FEC code relevant fields might be as follows: Real_time_parameters delta_t, table_boundary, frame_boundary can be as in EN 301192, with 18 bits of padding information, as described below for FEC code. 
         [0038]    FEC_data_byte: This field contains the OFEC data delivered 
         [0039]    CRC — 32: This field is as defined by ISO/IEC 13818-6. It is calculated over the entire MPE-OFEC_section. 
       1.3 FEC Streaming Configuration Information 
       [0040]    The FEC streaming configuration information (e.g., no_of_rows R, and maximum size of data bursts N B ) is independent of the FEC code. 
         [0041]    2. Different FEC Schemes 
       2.1 FEC Object Transmission Information 
       [0042]    For specific FEC codes, several of the above parameters and fields need to be defined explicitly. This information is generally referred to as FEC Object Transmission Information, which is specific to a particular FEC scheme. The FEC Object Transmission Information is defined by each FEC Scheme. The protocol defines a means to transport the FEC Object Transmission Information from the sender to the receiver. This then defines a complete delivery protocol. 
         [0043]    Specifically, the following parameters get defined: 
         [0044]    The table_id for the FEC section 
         [0045]    The FEC code 
         [0046]    The parameters of the code, Kmax, and Nmax 
         [0047]    The encapsulation of the FEC sections 
         [0048]    The transport of FEC Object Transmission Information 
         [0049]    Other parameters 
       2.2 MPE-FEC 
       [0050]    The regular MPE-FEC can be expressed in this framework. The following definitions are an example of a sufficient definition: 
         [0051]    The table_id for the FEC section is 0x??? 
         [0052]    The FEC code is the RS as defined in EN 301192 
         [0053]    The parameters of the code are Kmax=191, and Nmax=64 
         [0054]    The encapsulation of the FEC sections is according to EN 301192, section 9.8 
         [0055]    The parameters from above are
       B=1   S=1   D=1   F=1   M=1   T=R   M=1   X=1   Y=1
 
2.3 Extended MPE-FEC with Reed-Solomon Codes
       
 
         [0065]    The extended MPE-FEC with RS codes can be expressed in this framework. The following definitions are an example of a sufficient definition: 
         [0066]    The table_id for the FEC section is 0x??? 
         [0067]    The FEC code is the RS as defined in EN  301192   
         [0068]    The parameters of the code are Kmax=191, and Nmax=64 
         [0069]    The encapsulation of the FEC sections is according to SSP0178, section 5 
         [0070]    The parameters from above are
       B=1, . . . , Bmax   S= 1 , . . . , Smax   D=0   F=1   T=R   M=(B+S)   X=1   Y=B+S+1       
 
         [0079]    Note that the parameters for F and D could possibly also be loosened for an RS code similar to what is shown below for MSCR codes. However, the flexibility would be significantly lower. 
         [0000]    2.4 Extended MPE-FEC with MSCR Codes with Fixed Parameters 
         [0080]    The extended MPE-FEC with MSCR codes can be expressed in this framework. Below is an example of how one could apply quite fixed parameter settings: 
         [0081]    The table_id for the FEC section is 0x??? 
         [0082]    The FEC code is the MSCR code as defined in DVB A101 [3] 
         [0083]    The parameters of the code are Nmax=57344 
         [0084]    The other parameters from above are 
         [0000]    
       
         
               
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 F = 1, . . . , 32 
                 (5 bit) 
               
               
                   
                 B = F, 2F, 3F, . . . , 32F 
                 (5 bit) 
               
               
                   
                 S = F, 2F, 3F, . . . , 16F 
                 (4 bit) 
               
               
                   
                 D = 0, (B + S)/2, B + S, −(B + S)/2 
                 (2 bit) 
               
               
                   
                   
               
             
          
         
       
     
         [0085]    Parameter Generation for T and Kmax: 
         [0000]    
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 T = R; 
               
               
                   
                 while( (F*(Nb/T)) &lt;= 4000 &amp;&amp; ( T&gt;32 ) ) 
               
               
                   
                 { 
               
               
                   
                   T/=2; 
               
               
                   
                 } 
               
               
                   
                 Kmax = F*ceil(Nb/T); 
               
               
                   
                 M = (MAX(B−D, D−B)+S)/F; 
               
               
                   
                 X = MAX(1, D); 
               
               
                   
                 Y = MAX(B−D, D−B)+S+1; 
               
               
                   
                   
               
             
          
         
       
     
         [0086]    FEC Relevant Information: 
         [0000]    
       
         
               
               
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 EncodingFrequency F 
                 5 
                 uimsbf 
               
               
                   
                 DataSpread B 
                 5 
                 uimsbf 
               
               
                   
                 FECSpread 
                 4 
                 uimsbf 
               
               
                   
                 AheadSending 
                 2 
                 uimsbf 
               
               
                   
                 SectionNumber 
                 8 
                 uimsbf 
               
               
                   
                 BurstNumber 
                 8 
                 uimsbf 
               
               
                   
                   
               
             
          
         
       
     
         [0087]    Padding Information: 
         [0000]    
       
         
               
               
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 BurstNumberBackwards 
                 5 
                 uimsbf 
               
               
                   
                 NoDataColumns 
                 13 
                 uimsbf 
               
               
                   
                   
               
             
          
         
       
     
         [0088]    Syntax 
         [0089]    See above for FEC Relevant Information 
         [0090]    BurstNumberBackwards: gives number 0, . . . , 31, pointing back to burst to which NoDataColumns refers to. 
         [0091]    NoDataColumns in burst i-BurstNumberBackwards 
         [0000]    2.5 Extended MPE-FEC with Flexible Parameters 
         [0092]    The extended MPE-FEC with MSCR codes can be expressed in this framework. Below is an example of one expression in this framework: 
         [0093]    The table_id for the FEC section is 0x??? 
         [0094]    The FEC code is the MSCR code as defined in DVB A101 [3] 
         [0095]    The parameters of the code are Kmax&lt;8192, and Nmax=57344 
         [0096]    The parameters from above are 
         [0000]    
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 F = 1, . . . , 32 
               
               
                   
                 B = F, 2F, 3F, . . . , 32F 
               
               
                   
                 D 
               
               
                   
                 T 
               
               
                   
                 M 
               
               
                   
                   
               
             
          
         
       
     
         [0097]    B, F, D, M, Y, and T are transmitted in the setup, e.g., in the INT table. 
         [0098]    Example Parameter Generation now at transmitter only: 
         [0000]    
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 T = R; 
               
               
                   
                 while( (F*(Nb/T)) &lt;= 4000 &amp;&amp; ( T&gt;32 ) ) 
               
               
                   
                 { 
               
               
                   
                   T/=2; 
               
               
                   
                 } 
               
               
                   
                 Kmax = F*ceil(Nb/T); 
               
               
                   
                   
               
             
          
         
       
     
         [0099]    Encapsulation of FEC Relevant Information can be as follows: 
         [0000]    
       
         
               
               
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 SourceBlock 
                 8 
                 uimsbf 
               
               
                   
                 SectionNumber 
                 8 
                 uimsbf 
               
               
                   
                 BurstNumber 
                 8 
                 uimsbf 
               
               
                   
                   
               
             
          
         
       
     
         [0100]    Encapsulation of Padding Information can be as follows: 
         [0000]    
       
         
               
               
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 BurstNumberBackwards 
                 5 
                 uimsbf 
               
               
                   
                 NoDataColumns 
                 13 
                 uimsbf 
               
               
                   
                   
               
             
          
         
       
     
         [0101]      FIG. 1  shows one example of how the FEC Streaming Framework described in this invention fits into the architecture of this system. 
         [0102]    Further embodiments can be envisioned to one of ordinary skill in the art after reading this disclosure. In other embodiments, combinations or sub-combinations of the above disclosed invention can be advantageously made. The example arrangements of components are shown for purposes of illustration and it should be understood that combinations, additions, re-arrangements, and the like are contemplated in alternative embodiments of the present invention. Thus, while the invention has been described with respect to exemplary embodiments, one skilled in the art will recognize that numerous modifications are possible. 
         [0103]    For example, the processes described herein may be implemented using hardware components, software components, and/or any combination thereof. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense. It will, however, be evident that various modifications and changes may be made thereunto without departing from the broader spirit and scope of the invention as set forth in the claims and that the invention is intended to cover all modifications and equivalents within the scope of the following claims.