Abstract:
The techniques related to providing a live program over the Internet are described. According to one aspect of the techniques, a data stream representing a live program is preprocessed to produce a plurality of substreams, each of the substreams comprising decimated samples of the data stream. The number of substreams is relatively large so that the bandwidth requirement for delivering one of the substreams is relatively low. With a group of seeding boxes receiving the substreams, a group of boxes in services are designated to receive the substreams from the seeding boxes, each of these boxes including the seeding boxes is able to support multiple outbound streams (e.g., greater than 2) so that there are enough data suppliers to service the ordering boxes or colonize more boxes to become the data suppliers. As a result, a live program can be timely serviced by peer boxes, significantly reducing the computation and bandwidth burdens on a server(s).

Description:
CROSS-REFERENCE TO RELATED APPLICATION 
     This application a continuation of U.S. application Ser. No. 11/831,938, filed Jul. 31, 2007, which is a continuation-in-part of U.S. application Ser. No. 11/684,637, filed Mar. 12, 2007, which is also a continuation of U.S. application Ser. No. 11/077,411, filed Mar. 9, 2005, which are hereby incorporated herein by reference in its entirety. 
    
    
     BACKGROUND 
     1. Technical Field 
     The present invention relates generally to the area of delivering multimedia services over the Internet, and more particularly to techniques for distributing live programs (e.g., video or audio) to subscribers using a data network, where client machines associated with the subscribers are configured to provide needed bandwidths to deliver the live programs with a minimum delay. 
     2. Description of the Related Art 
     Live programs, such as Oscar award evening, are traditionally broadcast over the air, in cable or via satellite. Since the Internet has been introduced as an alternative type of medium to reach the audience, efforts to broadcast live programs have led to many paradigms surrounding the well-known client-server architecture. In the server-client architecture, a server starts to feed a stream of a live program to a client upon receiving an order therefrom. Although the server-client architecture is relatively easy to implement and deployed, it was soon proved to be inefficient and incapable of supporting a large number of requests. When a live program becomes highly demanding, a server or a cluster of servers start to experience the bandwidth pressures when more and more clients request the same program at the same time. 
     One of the proposals to avoid the bandwidth pressures is to use distributed networks, namely each of participating client machines becoming potentially a server to provide feeding data to an ordering machine. An example is BitTorrent which is a peer-to-peer file sharing (P2P) communications protocol. BitTorrent is a method of distributing large amounts of data widely without involving an original distributor. Instead, when data is distributed using the BitTorrent protocol, recipients each supply data to newer recipients, reducing the cost and burden on any given individual source, providing redundancy against system problems, and reducing dependence upon the original distributor. However, BitTorrent does not support an “instant” playback of an ordered program. Often a user has to wait for an unpredictable amount of time before data from different places is received and assembled for playback. So BitTorrent, as of the current status, could hardly support a live broadcasting program. 
     U.S. Pat. No. 7,191,215 discloses unique techniques of providing media services among clients with a central server as a manager or regulator.  FIG. 1  duplicates FIG. 2A of U.S. Pat. No. 7,191,215, that shows an exemplary configuration  200  of a distributed network system. A server  202 , presumably managed and/or populated by a service provider, is configured to handle the delivery of video (or multimedia) services to users via local machines or boxes  206 - 1 ,  206 - 2 , . . .  206 - n . Different from the client-server architecture in which a server is caused deliver video data to a subscriber upon receiving a request therefrom, the server  202  is not responsible for delivering the content in response to a request from a user, and instead, it is configured to provide source information as to where and how to retrieve at least some of the content from other clients (e.g., boxes). In other words, a server in the typical client-server architecture requires to have a direct access the content when servicing the clients, while the server  202  does not need necessarily to access the content to provide the content to the clients. Instead, some of the boxes  206 - 1 ,  206 - 2 , . . .  206 - n  are respectively configured to supply part or all of the content to each other. 
     According to one embodiment, when fulfilling a request from a local machine or a box (e.g.,  206 - 1 ), communication between the server  202  and the box  206 - 1  over the network paths  208 - 1  and  210  may be limited to small-scale requests and responses (e.g., of small size and very short). A server response to a request from a box may include source information (e.g., identifiers), authorization information and security information. Using the response from the server  202 , the box may be activated to begin playback of a title (e.g.,  207 - 1 ). Substantially at the same time, the box may initiate one or more requests to other boxes (e.g.,  206 - 2  and  206 - n ) in accordance with the source identifiers to request subsequent portions of the title (e.g.,  207 - 2  and  207 - n ). Assuming proper authorization, the requesting box receives the subsequent portions of the data concurrently from the other boxes. Because of box-to-box communication of content, the bandwidth requirement for box-to-server communications over the network paths  208 - 1  and  210  is kept low and typically short in duration. 
     In one aspect, U.S. Pat. No. 7,191,215 has fundamentally resolved the bandwidth issues that are experienced in the client-server architecture and made an entire video delivery system independent from the number of the users. In reality, U.S. Pat. No. 7,191,215 performs better with more users because more client machines available to supply requested data means more bandwidths for servicing others, while the client-server architecture starts to hit its limits when the number of its users exceeds a certain number. 
     The present invention discloses techniques for distributing a live broadcast program using a distributed network. As will be appreciated by those skilled in the art, one embodiment of the present invention may be advantageously used in a system designed in accordance with U.S. Pat. No. 7,191,215 but can also be used in general for distributing live contents over distributed networks. 
     SUMMARY 
     This section is for the purpose of summarizing some aspects of embodiments of the present invention and to briefly introduce some preferred embodiments. Simplifications or omissions in this section as well as in the title and the abstract of this disclosure may be made to avoid obscuring the purpose of the section, the title and the abstract. Such simplifications or omissions are not intended to limit the scope of the present invention. 
     Broadly speaking, the invention relate to techniques for providing media services over data networks. The techniques described herein are related to providing a live program over the Internet. A distributed network traditionally considered for delivering contents that are not of live or instant nature, the present invention discloses techniques of delivering live programs relying on client machines (e.g., boxes) by peer-to-peer communication. According to one aspect of the present invention, a data stream representing a live program is preprocessed to produce a plurality of substreams, each of the substreams comprising decimated samples of the data stream, wherein the data stream is continuously coming till the live program ends. The number of substreams is relatively large so that the bandwidth requirement for delivering one of the substreams is relatively low. To playback the live program on an ordering box, the substreams are preferably streamed in nearly simultaneously so that data blocks can be multiplexed to recover the data stream for the playback. 
     With a group of seeding boxes receiving the substreams, a group of boxes in services are designated to receive the substreams from the seeding boxes, each of these boxes including the seeding boxes is able to support multiple outbound streams (e.g., greater than 2) so that there are enough data suppliers to service the ordering boxes or colonize more boxes to become the data suppliers. At the same time, each of the ordering boxes is a potential data supplier to supply one or more of the substreams to other ordering boxes. 
     One of the important features in the present invention is to generate a fairly large number of substreams from a data stream representing a live program, each of the substreams requiring a low bandwidth for transmission over a network. As a result, boxes that have a sufficient downloading bandwidth to receive a substream and a sufficient uploading bandwidth to supply the substream to more than two other boxes are qualified to be the data suppliers of the live program. Essentially, the computation and bandwidth burdens that would otherwise be on a server are now distributed to such boxes. 
     Embodiments of the invention may be implemented in numerous ways, including a method, system, device, or a computer readable medium. Several embodiments of the invention are discussed below. In one embodiment, the invention provides a method for distributing a live program over a distributed network, the method comprises: preprocessing a data stream representing the live program into a plurality of substreams, each of the substreams comprising decimated samples of the data stream, wherein the data stream is continuously coming till the live program ends; identifying boxes in service that are idle; selecting a set of seeding boxes from the idle boxes to receive the substreams; and causing the seeding boxes to propagate the substreams as being received to other of the idle boxes so that there are a sufficient number of suppliers to provide the substreams to ordering boxes. 
     In another embodiment, the invention provides a system for distributing a live program over a distributed network, the system comprises a server configured to generate N substreams that are created from a data stream representing the live program into, each of the N substreams comprising decimated samples of the data stream, wherein the data stream is continuously coming till the live program ends, and N is a finite integer; a plurality of boxes in service that are idle, wherein a set of seeding boxes from the idle boxes is selected to receive the substreams from the server and caused to propagate the N substreams as being received to other of the idle boxes; and a plurality of ordering boxes to order the live program, each of the ordering boxes receiving the N substreams from N of the idle boxes, wherein each of the N of the idle boxes is capable of servicing one or more ordering boxes. 
     One of the objects, features, and advantages of the present invention is to provide a mechanism for broadcasting a live program over a distributed network. 
     Other objects, features, and advantages of the present invention will become apparent upon examining the following detailed description of an embodiment thereof, taken in conjunction with the attached drawings. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The invention will be readily understood by the following detailed description in conjunction with the accompanying drawings, wherein like reference numerals designate like structural elements, and in which: 
         FIG. 1  duplicates FIG. 2A of U.S. Pat. No. 7,191,215, that shows an exemplary configuration of a distributed network system; 
         FIG. 2  shows that a data stream representing a live program is being preprocessed to produce eight substreams; 
         FIG. 3A  shows an exemplary configuration of delivering a live program using some of the boxes in service to serve the ordering boxes; 
         FIG. 3B  shows a flowchart or process of serving a live program using a distributed network according to one embodiment of the present invention; 
         FIG. 4A  shows a flowchart or process of managing the distribution of segments pertaining to a title to boxes in services according to one embodiment of the present invention; 
         FIG. 4A  shows a pipeline structure to propagate a substream being received to a number of boxes serially; 
         FIG. 4B  shows a multicast tree by arranging all eligible boxes in a d-ary (d&gt;1) tree structure with a minimum delay in time; 
         FIG. 4C  shows a diagram of distributing substreams to eligible boxes using a random approach. 
         FIG. 5A  shows an ordering box being services by peer boxes receiving the substreams; and 
         FIG. 5B  shows a multiplexing process of four substreams to recover a data stream for playback according to one embodiment of the present invention. 
     
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     In the following description, numerous specific details are set forth to provide a thorough understanding of the present invention. The present invention may be practiced without these specific details. The description and representation herein are the means used by those experienced or skilled in the art to effectively convey the substance of their work to others skilled in the art. In other instances, well-known methods, procedures, components, and circuitry have not been described in detail since they are already well understood and to avoid unnecessarily obscuring aspects of the present invention. 
     Reference herein to “one embodiment” or “an embodiment” means that a particular feature, structure, or characteristic described in connection with the embodiment can be included in at least one implementation of the invention. The appearances of the phrase “in one embodiment” in various places in the specification are not necessarily all referring to the same embodiment, nor are separate or alternative embodiments mutually exclusive of other embodiments. Further, the order of blocks in process, flowcharts or functional diagrams representing one or more embodiments do not inherently indicate any particular order nor imply limitations in the invention. 
     As used herein, the singular forms “a”, “an”, and “the” are intended to include the plural forms as well, unless the context indicates otherwise. It will be further understood that the terms “comprises” and/or “comprising” specify the presence of stated features, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, steps, operations, elements, components, and/or groups thereof. 
     Embodiments of the present invention are discussed herein with reference to  FIGS. 1-5B . However, those skilled in the art will readily appreciate that the detailed description given herein with respect to these figures is for explanatory purposes only as the invention extends beyond these limited embodiments. 
     Typically, broadcasting a live event involves these major parts, audio and/or video capture, signal acquisition, content encoding, and delivery or distribution. The first piece of any live event is audio and video content. Some events consist of just an audio component, such as a quarterly corporate release call, while others consist of video as well as audio, such as Oscar award evening. The first step in any live event is being able to record and film the content, otherwise known as “audio and/or video capture”. 
     Once the audio/video content is captured, a signal acquisition process is immediately followed. The signal is transmitted to a location where it can be encoded. This process is typically done a few different ways depending on the event. The signal can be sent to a satellite in the sky (typically refereed to as “uplinking”) where it is then pulled down (otherwise known as “dowlinking”) at the service provider&#39;s offices for encoding. Another way to capture the signal can be via a phone bridge, say if the live event content consists of just a conference call. The signal can also be sent via connectivity at the event location if the content is being encoded on-site from the venue. 
     After the signal has been acquired, it needs to be encoded for distribution over the Internet. Encoding the content includes taking the audio/video signal and transforming it into a streaming media file format ready for distribution on the Internet. Encoding is done by using an “encoder”, a hardware based device with capture cards and software that allows the signal to be digitized into one of file formats that can be placed back on a computer device. Now that the content has been captured, acquired and encoded, it is ready for delivery, which also can be referred to as “distribution”. 
     In the context of the present invention, broadcasting a live program includes broadcasting a live event, further it includes broadcasting data that is preferably viewed/listened/executed at the time the data is being released over the internet. Accordingly, one aspect of the present invention pertains to distributing the encoded data (that may also be compressed) using distributed networks with a minimum delay in time. 
     For convenience, it is assumed herein data (e.g., audio and/or video) representing a live program is presented in a data stream (or a streaming data file) that comes in until the live program ends. When an order for a live program is placed, a corresponding stream (namely, the beginning portion thereof) must be available for playback. To take advantage of the available bandwidths on the side of the client machines (e.g., boxes), and minimize the delay caused by the distribution of the data over the network, the data stream is preprocessed as shown in  FIG. 2 . As a live program is going on, a data stream  240  representing the live program is divided into a plurality of interleaved data substreams, for example, 50-100 substreams. To illustrate what an interleaved data substream is,  FIG. 2  shows that a data stream  240  is being preprocessed to form eight interleaved data substreams  247 - 254 . The data substreams  247 - 254  are produced or formed by respectively sampling the data stream  240  in a decimated manner. 
     In operation, as the data stream  240  comes in (until the live program ends), a certain sized data block goes to (or is sampled to) each of the substreams  247 - 254 , in a sequential order repeatedly. For example, there are eight substreams, a 1st block goes to a first substream, a 2nd data block goes to a second substream, and a 8th data block goes to a eighth substream. As 9th, 10th, . . . 16th data block come, they go to the first, the second, . . . and the eighth substreams, respectively. In another perspective, an n-th data block in each of the substreams  247 - 254  is one of the eight successive data blocks in the data stream  240 . In one embodiment, a data block comprises a chunk of data, for example, 256 Kbytes or 1 Mbyte. As a result, each of the data substreams  247 - 254  includes a plurality of interleaved data blocks from the data stream  240 . 
     As shown in  FIG. 2 , the data stream  240  is expressed in data blocks as follows: b11, b21, b31, b41, b51, b61, b71, b81, b12, b22, b32, b42, b52, b62, b72, b82, . . . b1n, b2n, b3n, b4n, b5n, b6n, b7n, b8n. With the decimated sampling, the eight substreams  247 - 254  obtained can be respectively expressed as follows: 
     substreams 1={b11, b12, b13, b14 . . . }; 
     substreams 2={b21, b22, b23, b24 . . . }; 
     substreams 3={b31, b32, b33, b34 . . . }; 
     substreams 4={b41, b42, b43, b44 . . . }; 
     substreams 5={b51, b52, b53, b54 . . . }; 
     substreams 6={b61, b62, b63, b64 . . . }; 
     substreams 7={b71, b72, b73, b74 . . . }; and 
     substreams 8={b81, b82, b83, b84 . . . }. 
     where b stands for “data block”, numerals after “b” are mere reference numbers. As used above, the data blocks b11, b21, b31, b41, b51, b61, b71, b81, b12, b22, b32, b42, b52, b62, b72, b82, . . . b1n, b2n, b3n, b4n, b5n, b6n, b7n, b8n are sequential while, for example, data blocks b11, b12, b13, b14 . . . bin in substreams 1 are not sequential (interleaved). In other words, the data blocks in each of the substreams are non-sequential. Data streams from all substreams must be multiplexed to reproduce useful (sequential) data for playback on an ordering box. 
     Instead of counting on limited computation power and bandwidth of a server, one of the features in the present invention is to utilize that of the boxes in service and distributed in the network. Typically, there are tens and thousands of boxes in service by a service provider. At the time of broadcasting a live program, there can be a substantial number of boxes that are not used to fulfill an order (e.g., playing back a movie, or browsing the Internet) or boxes that are not fully occupied. These boxes, referred to herein as being idle at the time, may contribute substantially to the required computation power as well as the required bandwidth to deliver the live program to those boxes that have ordered the live program from the service provider. 
     For example, for a typical residential environment, a downloading speed is about 1.3 Mbps while an uploading speed is 330 Kbps, and the data stream of a live program requires a transmission speed of 900 Kbps. If the data stream is being preprocessed to form sixty substreams that are being distributed to sixty idle boxes, either from the server or from other idle boxes, these sixty idle boxes can be designated to provide the substreams to ordering boxes, each substream at an uploading speed of 15 Kbps that can readily achieved in the residential environment. 
     In one embodiment, there may be many idle boxes, but only those idle boxes that have a sufficient uploading bandwidth to serve multiple ordering boxes are designated by the server to be data suppliers of the live program, thus receiving the substreams from the servers. The minimum requirement of an idle box to be a supplier is that the uploading bandwidth thereof can support at least two substreams, namely, an idle box that is qualified to be a data supplier can serve at least two others (e.g., ordering boxes or other idle boxes). 
       FIG. 3A  shows a configuration  300  of delivering a live program using some of the idle boxes in service to serve the ordering boxes. It is assumed that a server  302 , representing a single server or a cluster of servers, distributes substreams to identified idle boxes  304 . On behalf of the server  302 , the idle boxes  304  are caused to fulfill the orders of the live program from the ordering boxes by feeding the required substreams thereto, thus alleviating the computation and bandwidth pressures on the server  302 . 
       FIG. 3B  shows a flowchart or process  322  of serving a live program using a distributed network according to one embodiment of the present invention. The process  322  may be understood in conjunction with  FIG. 3A , and implemented in software, hardware, or in a combination of both. At  322 , the process  322  determines a set of seeding boxes from the idle boxes. In one embodiment, a server has a status record of all boxes in service to show which ones are currently busy (e.g., playing back an ordered movie or uploading a data stream to another box) and which ones are not busy or could contribute to the delivery of the live program, also referred to herein as eligible boxes. Those being eligible are identified as the potential data suppliers of the substreams to others for the live program. In another embodiment, the server determines an uploading bandwidth a box has. A box will be identified as a potential supplier when the available uploading bandwidth thereof is sufficient to serve at least two other boxes in accordance with the required transmission rate (e.g., related to the encoding and decoding rates for successful playback) and the number of substreams. For example, a data stream of a live program requiring a transmission rate of 900 Kbps is partitioned into 60 substreams. Accordingly, if a box has an at least 30 Kbps uploading bandwidth, it will be considered as a potential supplier. In any case, among the potential suppliers, the server selects a set of seeding boxes to receive the substreams directly therefrom. Although it is possible to designate more seeding boxes to directly receive the substreams from the server, the more seeding boxes there are, the more computation and bandwidth are required form the server. Thus depending on the computation power and the bandwidth of the server, the set of the seeding boxes may be an exact number of the substreams, one to receive a substream, or more in which two or more to receive a substream. 
     At  324 , the data stream representing the live program is preprocessed to generate the substreams. The number of the substreams is determined in accordance with a number of factors. For example, the factors include, but may not be limited to, a required transmission rate of a video over a network, a number of data suppliers required to supply the substreams to an ordering device, a number of eligible boxes or boxes that could potentially become the suppliers, and available uploading and downloading bandwidths of the boxes in service. 
     Given the selected set of potential suppliers from the idle boxes, at  326 , the server can be configured to start to stream the substreams, respectively, to the seeding boxes. For example, one of the seeding boxes is caused to receive one substream as the substream becomes available. It should be noted that the bandwidth pressure on the server is not increased although the server is configured to feed, for example, N substreams to N boxes, which is equivalent to feed a data stream of the live program to a single box. 
     As the seeding boxes are receiving the substreams, they are configured to propagate the received data to other eligible boxes that can be the potential suppliers at  328 . One of the purposes is to colonize more eligible boxes to receive the substreams so that more ordering boxes may be served, and at the same time, there are still sufficient data suppliers should some of the eligible boxes become ordering boxes (e.g., some subscribers order the live program in the middle of the program). Although there are ways to propagate the received data to other eligible boxes, according to one embodiment, a scheme is adopted to propagate the substreams to other the eligible boxes with a minimum delay in time. The details of exemplary propagating the received data of a substream to other eligible boxes will be described below. 
     At  330 , a set of data suppliers is identified to serve an ordering box. As the eligible boxes are receiving the substreams from the server or other eligible boxes, a set of the eligible boxes is designated by the server to serve the ordering box. As described above, each eligible data supplier is capable of servicing at least two ordering boxes, an eligible data supplier may be designed to provide a substream being received to two or more ordering boxes or a combination of ordering boxes and other eligible boxes. 
     It should be noted, however, while an ordering box is receiving all the substreams from a set of suppliers, it may be designated as a supplier to supply one or more of the substreams being streamed to another ordering box. 
       FIG. 4A  shows an exemplary pipeline structure to propagate a substream being received to a number of boxes that are designed to receive such a substream. As the server releases a substream block by block to C1 that pipelines it to C2 and so on till to Cn. The completion time for this structure will be k(n−1) ticks, assuming it takes k ticks (a time unit) to get one data block from one device to another. The completion time in the pipeline structure depends linearly on the number of boxes to be populated with one substream. 
       FIG. 4B  shows a multicast tree by arranging all eligible boxes in a d-ary (d&gt;1) tree structure. If all the eligible boxes and the server are represented by N nodes. There will be at most log.sub.dN layers, resulting in a completion time being k.times.log.sub.dN ticks, again it is assumed that it takes k ticks (a time unit) to get one data block from one device to another. The completion time in the multicast tree depends logarithmically on the number of boxes to be populated with one type of the substreams. It could be appreciated by those skilled in the art that the tree structure may be optimized to minimize the delay in time in propagating the substreams to all eligible boxes or in colonizing the eligible boxes to receive the substreams. 
       FIG. 4C  shows a diagram  400  of distributing the substreams to eligible boxes using what is referred to as a gossip protocol. Instead of predetermining which eligible boxes are supposed to receive the substreams from which boxes, the way of colonizing the eligible boxes to receive the substreams is somehow random. When a server starts to release the substreams, it is configured to prepare the substreams into a number of data chunks. A data chunk is an atomic unit of data transfer from the server to the boxes, or between two boxes. For example, each of the data chunks may be 1 Mbyte in size and uniquely identified. Depending on implementation, each data chunk may contain one or more data blocks from one substream. In one embodiment, the server prepares a sourcing instruction in metadata about the substreams. The instruction, for example, describes which box gets which one of the substreams. The instruction once received causes an eligible box to retain the data blocks pertaining to the substream that it is supposed to receive. 
     The instruction, once prepared by the server, is propagated to all eligible boxes either via direct communication between the server and a box, or by box-to-box propagation of the instruction via a gossip protocol which is an application-layer multicast-like protocol. In general, each of the eligible boxes is configured to receive a specific subset of the data chunks that make up a substream assigned thereto. In addition, the sourcing instruction itself may be represented as one or more data chunks that are to be propagated to all boxes. 
     In operation, the server  402  initiates respective communications with a set of eligible (seeding) boxes  404 - 1 ,  404 - 2 , . . .  404 - n  and provides each of them with the data chunks in a substream that box is supposed to receive. Preferably, at least one of the seeding boxes receives data chunks of a corresponding substream from the server  402 . The exact number of the seeding boxes  404 - 1 ,  404 - 2 , . . .  404 - n  initially to receive the data chunks does not constrain the distribution of the substreams. In one embodiment, the designation of the boxes  404 - 1 ,  404 - 2 , . . .  404 - n  is also fairly random. In another embodiment, the designation of the boxes  404 - 1 ,  404 - 2 , . . .  404 - n  is based on corresponding internet service providers (ISP) or geographic locations. 
     Each of the seeding boxes  404 - 1 ,  404 - 2 , . . .  404 - n  is configured to spread data chunks to other eligible boxes based on the gossip protocol. It should be noted that not all of the boxes  404 - 1 ,  404 - 2 , . . . and  404 - n  have received identical data chunks. Any of the boxes  404 - 1 ,  404 - 2 , . . . and  404 - n  may start to spread a data chunk to other boxes as soon as it has received the data chunk in its entirety. In operation, the box  404 - 1  is assigned to propagate at least some of its received data chunks to boxes  406 - 1 ,  406 - 2  and  406 - 3 , communicating with one or more of these boxes simultaneously. The box  404 - 2  is assigned to propagate at least some of its received data chunks to boxes  406 - 2  and  406 - 3 . The box  406 - 2  is configured per the instruction to know exactly what data chunks to get from the box  404 - 1 , the box  404 - 2 , and any other boxes configured to feed it chunks of data. Further, the box  406 - 2  is assigned to propagate at least some of its received data chunks to boxes  408 - 1 ,  408 - 2  and  408 - 3 . Note that the propagation of data is not necessarily hierarchical. For example, box  408 - 1  might send data chunks “backward” to  406 - 1 , as seen in  FIG. 4A . 
     In one embodiment, the data chunks are propagated only to boxes that actually desire those particular chunks in order to avoid wasteful data transmission. Moreover, wasteful data transmissions may be avoided by ensuring that a data chunk is propagated to a box only if it does not already possess that chunk and is not in the process of downloading that chunk from elsewhere. In one embodiment, if any one of the boxes, for whatever reason, fails to accept data chunks, the box could be dropped as a supplier or a substitute box could be configured to receive and spread the data chunk. By repeatedly and recursively propagating data chunks via boxes after boxes (i.e., by pulling or pushing), eventually all eligible boxes will be colonized to receive the substreams as they are streamed in. 
     Regardless what scheme is used to colonize the eligible boxes to receive the substreams, a map  409  identifying which box is receiving substream is established and maintained in a server. By the map  409 , whenever an order is received from an ordering box, the server can designate appropriate supplying boxes to supply the ongoing substreams to the ordering box. Alternatively, the map  409  enables an ordering box to obtain source information to fetch the substreams to fulfill an order. 
     In a case in which one of the supplying boxes could no longer supply a substream at a required speed, a substitute supplying box may be immediately called upon to continue supplying the substream. For example, an eligible box has been designated to supply a substream to a box (either an ordering box or another eligible idle box). This eligible box somehow becomes fully used (e.g., engaged to play back a movie), its bandwidths are no longer sufficient to support the deliver of the live program. One or more eligible boxes are determined to substitute this box to continue the original assigned substream. 
       FIG. 5A  shows that an ordering box is receiving N substreams from other peer boxes to fulfill an order of a live program. At the same time, the ordering box may become a data supplier to supply one or more substreams to another peer box, provided the uploading bandwidth thereof is sufficient. In general, the uploading bandwidth requirement for an ordering box to become a supplier is low, compared to an idle box. In one embodiment, as long as an ordering box can upload one substream to another peer box, the ordering box may be designated to become a candidate supplier. 
     As described above, the data blocks in each of the substreams are not sequential and can not be played back without being blended with that of all the substreams. In one embodiment, all the substreams are streamed in nearly simultaneously so that data blocks in all the substreams can be multiplexed to recover the original data stream for playback.  FIG. 5B  shows a buffer  570  in a box to receive a live program. It is assumed that the live program is originally represented by a data stream  560 . After being preprocessed, the data stream  560  is being partitioned into four substreams that are being released into a distributed network. These four substreams  578 - 581  are now being streamed in from four peer boxes. As shown in  FIG. 5B , as the substreams  578 - 581  are being received, they are multiplexed into the buffer  570 . More specifically, a block of data from the substream  578 , a block of data from the substream  579 , a block of data from the substream  580  and a block of data from the substream  582  are multiplexed and successively fed into the buffer  570 . As a result, the original order of the data blocks is restored. The live program can be played. 
     One skilled in the art will recognize that elements of a system contemplated in the present invention may be implemented in software, but can be implemented in hardware or a combination of hardware and software. The invention can also be embodied as computer-readable code on a computer-readable medium. The computer-readable medium can be any data-storage device that can store data which can be thereafter be read by a computer system. Examples of the computer-readable medium may include, but not be limited to, read-only memory, random-access memory, CD-ROMs, DVDs, magnetic tape, hard disks, optical data-storage devices, or carrier wave. The computer-readable media can also be distributed over network-coupled computer systems so that the computer-readable code is stored and executed in a distributed fashion. 
     The foregoing description of embodiments is illustrative of various aspects/embodiments of the present invention. Various modifications to the present invention can be made to the preferred embodiments by those skilled in the art without departing from the true spirit and scope of the invention as defined by the appended claims. Accordingly, the scope of the present invention is defined by the appended claims rather than the foregoing description of embodiments.