source data can be recovered from any subset of the encoded packets, given ... data. A DF decoder who wishes to recover the .... and running Linux OS. Table I ...
Sliding-Window Digital Fountain Codes for Streaming of Multimedia Contents Mattia C.O. Bogino, Pasquale Cataldi, Marco Grangetto, Enrico Magli, Gabriella Olmo Dipartimento di Elettronica - Politecnico di Torino Corso Duca degli Abruzzi 24 - 10129 Torino - Italy Ph.: +39-011-5644195 - Fax: +39-011-5644099 pasquale.cataldi(marco.grangetto,enrico.magli,gabriella.olmo)@polito.it
Abstract— Digital fountain codes are becoming increasingly important for multimedia communications over networks subject to packet erasures. These codes have significantly lower complexity than Reed-Solomon ones, exhibit high erasure correction performance, and are very well suited to generating multiple equally important descriptions of a source. In this paper we propose an innovative scheme for streaming multimedia contents by using digital fountain codes applied over sliding windows, along with a suitably modified belief-propagation decoder. The use of overlapped windows allows one to have a virtually extended block, which yields superior performance in terms of packet recovery. Simulation results using LT codes show that the proposed algorithm has better performance in terms of efficiency, reliability and memory with respect to fixed-window encoding.
I. I NTRODUCTION Digital Fountain codes (DF) are sparse-graph codes developed for erasure channels, and their key property is that the source data can be recovered from any subset of the encoded packets, given that enough packets are received. The DF concept can be described as follows. As a fountain that produces an endless supply of water drops, a DF encoder generates a potentially unlimited number of encoded symbols from source data. A DF decoder who wishes to recover the transmitted data must receive a sufficient number of encoded symbols, as a bucket that collects water drops until it is full. The number of symbols to be collected from the receiver is n = (1 + ε) k, where k is the number of source symbols and ε is the code overhead. It can be demonstrated [1] that for k → ∞ these codes have ε → 0, so they are potentially optimal. These codes are rateless in the sense that the number of symbols generated from the source data can be potentially infinite and can be determined on the fly. DF codes are also universal because the symbol length for the codes can be arbitrary, from one-bit binary symbols to general l-bit symbols, without affecting the coding and decoding efficiency. Approximations to DFs can be obtained by loosening some of the previous features in various ways. The first universal DF codes were invented by Michael Luby, and are called LT Codes. Such codes are asymptotically optimal rateless erasure correcting codes, but present non linear encoding/decoding complexity. Applications of DFs can be found in many areas of digital communications, such as data delivery across best effort networks, or reliable data storage on multiple disks [2], [3], [4],
[5]. Many multimedia applications, where the use of feedback channels between the sender and the many users is not possible can benefit from the DF approach. Besides their good performance and promising applications in many areas, DF codes also exhibit some weaknesses in the transmission of particular types of data. DFs are asymptotically optimal only for the number of source symbols tending to infinity; in practice, many applications require short data block length, so that DF codes introduce enough overhead to make them unsuitable. Video applications and the limited memory capabilities of the device impose some constraints on the receiving times of the frames to be played. In a transmission system that does not guarantee correct ordering of the packets, the received data referred to frames too far in the future might be discarded because of limited buffer size. Similarly, packets that contain information about already played frames are useless, and their reception is only a waste of resources. A possible solution could be to subdivide the data into smaller blocks [6], [7], but this may make the code inefficient. In order to overcome the weaknesses of DF in video applications, we propose an innovative encoding scheme, called Sliding Fountain (SF). The key feature of a SF system is to use a windowing approach to partition the information data. The Fountain encoder chooses the source symbols to be processed among those contained in a sliding window, which moves forward following the chronological order of the video stream. This approach guarantees a rough temporal ordering of the received packets, avoiding expired information to be processed and gradually providing packets regarding the future information needed. II. S LIDING W INDOWS The main idea of the proposed scheme is to virtually extend the block length k, so as enhance the performance of the DF code by reducing the overhead and increasing transmission reliability. In the proposed approach, the blockbased partitioning of the information, adopted by traditional fixed window media streaming systems and represented in Fig. 1(a), is replaced by a new windowing approach, represented in Fig. 1(b). The considered window starts from the beginning
(a)
(b) Fig. 1. Traditional Fixed Windows System versus Proposed Sliding Window System
of the stream and moves forward, in order to achieve some overlap. Window design consists of the choice of its length w, defined as the number of symbols it contains. The system parameter w should be selected as a trade-off among conflicting requirements. For example, w should be as large as possible in order to reach a certain coding efficiency, while it should be as short as possible to better maintain the chronological ordering of the source packets. Another system parameter to set and possibly optimize for the application at hand is the window movement s, which is equal to the number of old symbols discarded or new symbols considered for each window shift. This parameter also sets the amount of overlap between subsequent windows, which is w − s, and the number of successive windows that consider a particular symbol, which is w/s. The overlap strategy permits to virtually extend the window length considered w, as, decreasing s, the source symbols are considered in more successive windows and the virtual resulting block is enlarged. Introducing the SF scheme, it can be useful to determine the number of successive windows N that process all the source data. Considering a transmission that adopts the traditional block based partitioning of data, the window movement is equal to the window length, s = w, as no overlap between successive windows is considered, and the total number of window Nf is simply defined by N f = k/w, where k is the total number of source symbols and w is the window length. It can be easily verified that in a SF system the number of windows Ns of size w is k−w +1 Ns = s Moreover, a proper way of computing the total overhead has to be adopted, also in order to fairly compare the system with the traditional fixed window one. A conventional DF encoder, with a total overhead , generates n encoded symbols from k source ones: n = (1 + ) k On the contrary, a SF encoder processes each source symbol more than once. We have to guarantee that the total overhead
of the code is equal to that of traditional DF solutions. As the source symbols are processed in w/s successive windows, we can consider the original number of source symbols as virtually enlarged and equal to k : w k = k s Thus we can compute the number of symbols that can be generated, on average, for every virtual symbol: n s (1 + )k = (1 + ) = w k w sk Every window contains w source symbols, and this leads to the number of symbols that has to be generated from each window nw : nw = (1 + )s Thus, for every window the SF system generates a number of encoded packets which is smaller than the one needed in a traditional DF code in order to recover the whole information: n nw < = (1 + )w (1) Nf After having sent all the n w encoded symbols, the system moves the window forward, discarding the oldest s symbols and inserting an equal number of new ones. The overhead of the code defines the number of symbols sent and therefore the window speed. For these reasons, it should be carefully chosen considering both the channel and devices involved in the transmission, and the synchronization with the streaming data. The proposed SF decoder is a DF bucket that collects all the incoming symbols [8], and does not require to know that windowing is being used; it simply receives and processes every incoming symbol. As a consequence, when the window slides, two different cases can be observed. It can happen that all the symbols of the window have been solved. Unfortunately, this situation is not very likely to happen, because most of the time there are not enough checks to recover all the window source symbols. The common situation is rather that there are still unsolved equations, that will be solved using the new incoming symbols, because of window overlap. Therefore, the decoder requires a suitable amount of memory in order to store all the unsolved equations. The SF scheme is suitable for real-time applications because, in a given instant, the overlapped part of the windows are the most likely to be decoded. In fact, these symbols have more checks available for solving their equations. III. P ERFORMANCE A NALYSIS The performance analysis of the SF system using LT codes were performed through simulations of the entire system, varying the window speed and the total overhead of the code perceived at the decoder side. Thus, the simulation results have been proposed as a function of these parameters, while all the others were kept constant. The choice of the LT Robust Soliton distribution parameters, δ and c, should derive from a rigorous optimization process
Simulation Parameters LT Distribution parameters δ 0.5 c 0.1 Total source data per layer k 4 · 105 symbols Symbol length l 1 bit Window length w 4 · 104 symbols Overhead 0.00 . . . 0.20 Overlap [%] N s 0 10 4 · 104 symbols 50 19 2 · 104 symbols 75 37 1 · 104 symbols 87.5 73 0.5 · 104 symbols
simulations, with at least one undecoded symbol, over the total number of runs. The trend of the curves reproduces the one observed in Fig. 2, with the traditional system that fails every simulation for = 0.06. The SF systems with overlap of 75% and 87.5% and = 0.01 are still able to successfully decode the whole input data, respectively on about the 55% and the 85% of the total number of simulations. 1 Fixed Window Overlap 50% Overlap 75% Overlap 87.5%
0.9
TABLE I
0.8
S IMULATION PARAMETERS FOR THE S LIDING F OUNTAIN LT S YSTEM
[9], but this could be too expensive or impossible for many applications; thus, we decided to set them in order to achieve quite good average performance. The memory analysis is beyond the aims of this paper, so we decided to allocate a virtually infinite memory amount at the decoder side. The tests have been performed on an personal computer equipped with an Intel Pentium 4 processor 1700 MHz, 512 MB of Ram and running Linux OS. Table I summarizes all the parameters considered in the simulations.
Failure Probability
0.7 0.6 0.5 0.4 0.3 0.2 0.1 0
0
0.02
0.04
0.06
0.08
0.1
ε
0.12
0.14
0.16
0.18
0.2
Fig. 3. Simulation Failure Probability as a function of the Received Overhead
A. Failure Analysis Fig. 2 represents the probability of undecoded symbols (over the total simulated symbols). We can notice that, while the traditional fixed window system begins to significantly fail for = 0.08, the SF systems still exhibits good performance even for = 0.04. In addition, an increased overlap or a reduced window movement s, permits to reach the functioning limit of 2% of overhead added. This validates the virtual enlargement of the block size of the DF code, which leads to a significant reduction of the overhead needed to recover the original data. 0
10
Fixed Window Overlap 50% Overlap 75% Overlap 87.5%
log
In Fig. 4 the encoding times for the simulated systems are represented. As expected, we can observe a linear trend of the encoding times as a function of the number of generated encoded symbols. The encoding times decrease with decreasing received overhead . We can also note that the encoding times increase with decreasing overlap. This is mainly due to the ratio between the number of generated symbols per window and the window movements; the largest the overlap, the less symbols the encoder generates per window and the more windows have to be considered to process all the source data. 50
−2
10
45 −3
10
40 −4
10
35 −5
10
Time [s]
30
−6
10
10
(Ratio) (Undecoded/Total Symbols)
−1
10
B. Time Analysis
25 20
−7
10
15 −8
10
0
0.02
0.04
0.06
0.08
0.1
ε
0.12
0.14
0.16
0.18
0.2
10 Fixed Window Overlap 50% Overlap 75% Overlap 87.5%
5
Fig. 2.
Undecoded Symbols as a function of the Received Overhead
Fig. 3 represents the failure probability of the simulations. As failure probability we mean the number of unsuccessful
0
0
Fig. 4.
0.02
0.04
0.06
0.08
0.1
ε
0.12
0.14
0.16
0.18
0.2
Encoding Times as a function of the Received Overhead
0.7 Fixed Window Overlap 50% Overlap 75% Overlap 87.5%
0.6
Ratio (Peak/Total Symbols)
Fig. 5 represents the decoding times of the SF systems. As we can see, the SF scheme introduces some complexity, which leads to higher decoding times particularly when the overlap between successive windows grows. It can be noticed that when decreasing , the advantage of using fixed-windows also decreases. Indeed, at = 0.08, 50% overlapping is less complex than fixed-window solution. The fixed-window system does not work below = 0.07, while sliding-window solution does. Similarly, when = 0.03, the decoding process can not success for 50% overlap curve. Moreover, we can observe that the 50% and 75% overlap curves cross at some point; this means that, at small overheads, a large overlap can be beneficial in terms of complexity. Finally, we can observe that even for = 0.01 the sliding-window approach can work properly.
0.5
0.4
0.3
0.2
0.1
0
Fig. 6.
0
0.02
0.04
0.06
0.08
0.1
ε
0.12
0.14
0.16
0.18
0.2
Peak of Memory Usage as a function of the Received Overhead
900 Fixed Window Overlap 50% Overlap 75% Overlap 87.5%
800 700
Time [s]
600 500 400 300 200 100 0
0
Fig. 5.
0.02
0.04
0.06
0.08
0.1
ε
0.12
0.14
0.16
0.18
0.2
Decoding Times as a function of the Received Overhead
C. Memory Usage Analysis The last analysis we performed on the SF system is the memory usage of the decoder (Fig. 6). It can be noticed that, the amount of needed memory of traditional systems is always greater than FSs’. Nevertheless, the memory usage of SF solutions increases when the system begins to fail, as nearly all the received symbols can not be decoded and are memorized as unsolved equations. A memory management algorithm specific for the SF system could easily avoid this behavior of the decoder, as it could discard the useless symbols, optimizing the memory usage and therefore reducing the decoding times. IV. C ONCLUSIONS In this paper we presented an innovative Sliding Fountains transmission scheme. The SF system uses a windowing approach to partition the data instead of the traditional block-based approach used until now. The window, sliding through the data stream and leaving some overlap between successive steps, permits to virtually enlarge the data block length and to obtain a higher code efficiency. The proposed scheme exhibits an improvement in terms of reliability. In fact, keeping the overhead constant, SF approach
allows to achieve an undecoded symbol rate lower of 10 5 than traditional ones. Moreover, the SF encoding process is less complex while, at the decoder side, we can observe an increasing of decoding complexity with low values of , where besides traditional systems cannot work properly. Finally, a SF system needs a lower amount of memory with respect of a traditional one. The proposed system opens a wide range of possible future developments for many applications. In fact, the system parameters can be tuned in order to transmit multimedia contents over critical channels, and the SF scheme can be even modified so that an unequal error protection can be performed. R EFERENCES [1] M. Luby, “LT Codes,” in Symposium on Foundations of Computer Science. IEEE, November 2002, pp. 271–280. [2] J. W. Byers, M. Luby, M. Mitzenmacher and A. Rege, “A Digital Fountain Approach to Reliable Distribution of Bulk Data,” in ACM SIGCOMM ’98 Conference. ACM Press, 1998, pp. 56–67. [3] J. W. Byers, M. Luby and M. Mitzenmacher, “Accessing Multiple Mirror Sites in Parallel: Using Tornado Codes to Speed Up Downloads,” in INFOCOM. New York, NY: IEEE, March 1999, pp. 275–283. [4] J. W. Byers, M. Luby and M. Mitzenmacher, “A Digital Fountain Approach to Asynchronous Reliable Multicast,” IEEE Journal on Selected Areas in Communications, vol. 20, no. 8, October 2002. [5] A. G. Dimakis, V. Prabhakaran and K. Ramchandran, “Distributed Fountain Codes for Networked Storage,” in ICASSP. IEEE, May 2006, pp. 1149–1152. [6] H. Jenkac and T. Stockhammer, “Asynchronous Media Streaming over Wireless Broadcast Channels,” in ICME. IEEE, July 2005, pp. 1318– 1321. [7] J. P. Wagner, J. Chakareski and P. Frossard, “Streaming of Scalable Video from Multiple Servers Using Rateless Codes,” in ICME. IEEE, July 2006. [8] D. MacKay, Information Theory, Inference, and Learning Algorithms, 2nd ed. Cambridge University Press, December 2003. [9] P. Cataldi, M. Pedr`os Shatarski, M. Grangetto, E. Magli, “Implementation and Performance Evaluation of LT and Raptor Codes for Multimedia Applications,” in Proc. of 2006 IEEE International Conference on Intelligent Information Hiding and Multimedia Signal Processing (IIH-MSP), Pasadena, USA, December 2006.
