Abstract:
A method and an apparatus for creating a data block (Error Correction Code Block) comprising a plurality of data sectors, which data block is provided with parity information, and a method and an apparatus for recovering data sectors from a data block provided with parity information. A method for encoding or decoding data streams, respectively, which has a reduced memory requirement and manages with two encoders or decoders, respectively, and an encoding or decoding unit, respectively, for implementing the method, are proposed. In the case of a method for creating an ECC block comprising a plurality of data sectors, the data sectors being buffer-stored in the form of a block with a plurality of rows in a memory organized in the form of rows and columns and being provided with parity information, successively received blocks of data sectors are written row by row alternately to the rows or columns, respectively, of the memory.

Description:
FIELD OF THE INVENTION  
       [0001]     This invention relates to a method for processing data in a processing unit. In particular, the invention relates to a method for processing data in a processing unit, wherein the processing unit generates data frames for an output unit by combining data from a plurality of input units, and wherein said processing unit, input units and output unit are threads in a multithreading environment.  
       BACKGROUND  
       [0002]     Audio-visual (AV) presentations that are coded according to the Motion Picture Expert Group (MPEG) standard ISO/IEC-14496-1, known as MPEG-4 Systems, may consist of several data streams, e.g. one or more streams for video, one or more streams for audio, and others. The audio streams may have individual, usually standardized sample rates, e.g. 8 kb/s, 16 kb/s, 22.05 kb/s, 32 kb/s, 44.1 kb/s or 48 kb/s for different types of audio streams. Further, these streams consist of packets or frames with attached time-stamps.  
         [0003]     Reproduction of such presentations requires individual decoding units for different streams, a processing unit and one or more output units. These decoding, processing and output units may be implemented in so-called multithreading technique, using a microprocessor with operating system (OS) and application software, wherein the mentioned units are implemented as separate software partitions, also called “tasks” or “threads”. A thread is an independent unit of executable software that sequentially shares the control of the microprocessor with other threads. Since the threads are called and executed sequentially, they work asynchronously to each other, and may communicate with each other via a messaging application programming interface (API) provided by the operating system, or via function calls. Transmission of data between threads requires the data to be buffered, wherein usually synchronized FIFO-like structures are used for buffering. However, obtaining an acceptable quality of reproduction requires the output data stream, e.g. audio stream, to be continuous and complete at the output unit, i.e. any buffer underflows and buffer overflows must be prevented. To ensure constant data availability at the output unit, commonly a large FIFO buffer is used between the processing unit and the output unit.  
         [0004]     A conventional audio processing system is shown in  FIG. 1 . Decoded data blocks from a source stream are read from a decoder  11  via a frame FIFO  11   b  into a processing unit  14  where they are processed. The processed data blocks are written to a block-organized FIFO  15  that feeds the output module  16 . The output module  16  generates a continuous stream  17  of audio representation data from the data blocks that are read from the frame FIFO  15 , using several decoded data blocks simultaneously. When the FIFO  15  is not full, it sends a signal  18 , e.g. an exception message, to the processing unit  14 . Then the processing unit  14  processes more data from its input until the FIFO  15  is full. Such system may be implemented on a real-time operating system (RTOS) or on a non-RTOS like e.g. Microsoft Windows®. In the latter case, which is preferred because it is cheaper and simpler than a RTOS, separate threads 11T,14T,16T are used for the decoder  11 , the processing unit  14  and the output module  16 .  
       SUMMARY OF THE INVENTION  
       [0005]     For some applications it is desirable to process data from different sources simultaneously, wherein the sources may have different frame rates and/or sample rates and require separate decoders. E.g. it may be necessary to superpose audio signals from several inputs, e.g. ten or more.  
         [0006]      FIG. 2  shows a straightforward solution, connecting several decoders  11 , 12 , 13  to the processing unit  14 . The decoders  11 , 12 , 13  run in separate threads, and the thread management of the OS controls, by calling the respective threads, the order in which the different input data are processed. Typically a thread is active as long as it has data in an input buffer to process and space in an output buffer to write to. The processing unit  14  combines data from all its input buffers  11   b , 12   b , 13   b , and therefore requires data to be available in all these buffers. As a result, the time between successive calls of the processing unit  14  becomes longer than in a single input system, because each of the decoder units  11 , 12 , 13  tries to fill its respective output buffer  11   b , 12   b , 13   b  completely, as controlled by the thread management of the OS. Thus, also the total amount of input data to be processed is higher than in a single input system. This leads to stronger oscillations of the filling of the output buffer. Particularly when the microprocessor is heavily loaded, the system may become too slow to process the input streaming data, which require processing similar to real-time, and if the thread management is for general purpose and not optimized it may even block due to a kind of bottleneck effect. This may lead to data loss, i.e. not all input data arrive at the output module  16 , which is not acceptable for some data types, such as e.g. high quality audio data.  
         [0007]     The described multi-input system running under a non-RTOS e.g. in an audio-video presentation application leads to unpredictable timing behavior of the processing unit under heavy load, e.g. when input data from several different audio sources are to be processed while additionally the microprocessor has to perform other tasks. As a result, synchronization between audio and video is difficult due to unpredictable delay between the decoding of audio packets and audio rendering in the output unit. Further, the long time between successive calls of the processing unit thread also causes higher response time to user interactions, e.g. commands, which are in a multithreading system typically also executed by the processing unit. Thus, it takes longer for user commands to become effective.  
         [0008]     The problem to be solved by the invention is to provide a method for improving the timing behavior of a processing unit, wherein the processing unit generates data for an output unit by combining data from a plurality of input units, wherein all the mentioned units are threads in a multithreading environment and may have different time bases. A particular problem is to provide such method for an audio or audio-video reproduction device for multiple multimedia stream data. This problem is solved by the method disclosed in claim  1 .  
         [0009]     According to the invention, the timing behavior is improved by calling the processing unit in shorter time intervals, using a mechanism superordinate to the thread management of the OS. In particular, the invention comprises using a timer unit to call the processing unit thread, and setting the timer individually. Advantageously, this leads to a more even distribution of the microprocessors processing capacity. Further, the inventive method may increase the priority of the processing unit thread independent from the thread management of the OS, and reduce the oscillation of the filling of the output buffer. This leads e.g. to better audio-video synchronization and shorter delay for user interaction.  
         [0010]     Whenever the processing unit thread is called, the filling of the output buffer is measured, and the result of the measurement is used to determine the time before the next call of the processing unit thread. As long as the filling is below a defined threshold, e.g. during initialization, the processing unit repeats the cycle of processing a frame, writing it to the output buffer, and measuring again the output buffer filling, without setting the timer unit. When the output buffer has reached the threshold, a timer value is calculated from the measured output buffer filling, the timer unit is set with the calculated timer value, wherein the timer calls the processing unit thread when its time has elapsed, and the processing unit thread may be terminated until it is called again by the timer, or by thread management of the OS.  
         [0011]     The time period determined by the timer value is so that the processing unit will usually be called by the timer, and not by the thread management of the OS. Therefore, the time between the processing unit processing successive frames depends on the filling of the output buffer, which means that the regulation loop is closed, and thus the regulation is improved. Particularly when the output unit processes in regular time intervals, e.g. 80 ms, an output frame from the output buffer, and an output frame comprises a plurality of input frames, wherein each input frame has a specific sample rate, the invention comprises setting the timer to a value that corresponds to a common multiple of the reciprocals of the input sample rates, but is shorter than the output units time interval. It is particularly advantageous to pick a common multiple, or particularly the least common multiple, of the reciprocals of the input sample rates, e.g. 20 ms for sample rates of 48 kHz, 44.1 kHz, 32 kHz, 22.05 kHz, 16 kHz and 8 kHz, corresponding to reciprocals of 20.83 μs, 22.67 μs, 31.25 μs, 45.35 μs, 62.5 μs and 125 μs.  
         [0012]     When a timer is used to call the processing unit thread for processing the frames of a particular output data stream, e.g. audio data, and the load value of the timer depends on the filling of the output buffer, as proposed by the invention, the processing unit may after an initialization phase work in substantially equidistant time intervals. It may be advantageous to use an average buffer filling value for the calculation of the timer value. The average will be calculated over few measurement values from successive calls of the thread, e.g. 2-5 measurement values. A further low-pass filtering of the averaged measurement values can be used e.g. to improve the systems time behavior.  
         [0013]     A general purpose timer provided by common microprocessors can be employed to maintain on average a specified maximum time between processing successive frames for a particular output unit. The timer runs in real time, independent from the thread management. Microprocessors and/or operating systems usually provide such timers. The general-purpose timer triggers the processing unit thread for decoding the next frame. Then the timer is loaded with a new value, which is calculated from the filling of the buffer.  
         [0014]     Advantageously, a simple calculation can be used for this purpose, e.g. the averaged buffer filling may be input to a linear equation. In this case, it is also possible to input first the measurement value to a linear equation and then calculate an average. This method ensures lossless stream access, i.e. prevents buffer underflow and buffer overflow, and ensures constant minimum delay during processing. This is advantageous e.g. for better audio-video synchronization and quicker responses to user interaction.  
         [0015]     The time measured by the timer is an average maximum time with respect to the fact that the microprocessor may be busy with another task when it is triggered, so that it may have to finish the other task first before reacting on the trigger. This case can be handled when the output buffer is large enough for the output unit to continue working.  
         [0016]     As a consequence, the average number of data frames or blocks that are stored in the FIFO buffer between the processing unit and the output unit can be lower than in conventional systems, which leads e.g. to shorter response times, better estimation of the presentation time of the audio data, therefore improved audio-video synchronization, and generally better approximation of real-time behavior in a non-real-time system.  
         [0017]     An apparatus that utilizes the method is disclosed in claim  8 .  
         [0018]     The inventive apparatus for processing data receives input data from a plurality of inputs and comprises a microprocessor, a data set, e.g. program data, and a timer, wherein the microprocessor and the data set constitute a data processing unit and a data output unit, both units being threads in a multithreading environment, and wherein data are passed through a buffer from the processing unit to the output unit. Further, the apparatus comprises means for measuring a value corresponding to the filling of the output buffer and providing the value to the processing unit, means for calculating in the processing unit a timer value, wherein the timer value depends on said value corresponding to the filling of the output buffer, and means for setting the timer with the timer value and starting the timer, wherein the timer sends a notification when the time specified by the timer value is elapsed, the notification causing activation of the processing unit thread if it is not already active, or otherwise causing continued activation of the processing unit thread.  
         [0019]     The apparatus according to the invention is most advantageous to use if its inputs provide data with at least two different constant input data rates. The invention comprises that the timer is only used when the measured buffer filling is between predefined minimum and maximum values, and that the time specified by the timer value that results from a predefined average buffer filling value is the least common multiple of the reciprocals of the data rates of the inputs. Further, the relationship between the timer value and the output buffer filling value may be linear.  
         [0020]     The invention has the following advantages as compared to prior art: 
        First, a better approximation of real-time processing may be achieved on a system with non-real-time behavior.     Second, an improved time estimation of the presentation time of the output unit is possible, resulting in good synchronization, e.g. audio/video synchronization.     Third, it is possible to perform individual framewise and therefore optimized access to the source streams that are connected with the processing unit.        
 
         [0024]     Advantageous embodiments of the invention are disclosed in the dependent claims, the following description and the figures. 
     
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0025]     Exemplary embodiments of the invention are described with reference to the accompanying drawings, which show in  
         [0026]      FIG. 1 a  conventional single-input audio processing system;  
         [0027]      FIG. 2  an extended conventional audio processing system;  
         [0028]      FIG. 3  the timing of burstwise data frame transmission to the buffer in an extended conventional processing system;  
         [0029]      FIG. 4 a  buffer filling diagram for an extended conventional processing system;  
         [0030]      FIG. 5  an advanced audio processing system according to the invention;  
         [0031]      FIG. 6  equidistant processing of frames in an inventive processing system;  
         [0032]      FIG. 7 a  flow chart of the inventive data processing method;  
         [0033]      FIG. 8 a  buffer filling diagram for the inventive processing system; and  
         [0034]      FIG. 9  the timing behavior of the inventive processing unit thread. 
     
    
     DETAILED DESCRIPTION OF THE INVENTION  
       [0035]     In the following, the problem with prior art systems is described in more detail before preferred embodiments of the invention are described.  
         [0036]      FIG. 2  shows a processing unit  14  being the center of a system with several multimedia source streams, which are decoded by separate decoders  11 , 12 , 13  and buffered in separate buffers  11   b , 12   b , 13   b . The decoders  11 , 12 , 13  belong to separate time domains or threads that are independent from the time domain of the processing unit  14 . The processing unit  14  synchronizes the timestamps between the data from different sources. The output of the processing unit  14  is sent to a frame-oriented FIFO buffer  15 . A signal  18  from the buffer  15  transmits the buffer filling level to the processing unit  14 , thus requesting more data so as to prevent an underflow when the filling of the buffer  15  is below a defined level. The output of the buffer  15  is driven by an output module  16 , which requires in regular intervals data at the buffer output  17 . Thus, the output module determines the filling and also the frame-rate of the FIFO buffer  15 . The frame size of the output buffer  15  depends on the requirements of the output module  16 , but usually the buffer  15  is very large, e.g. fifteen frames. In a typical software realization of such a system, the output module  16  runs in its own thread that is independent from the other threads, particularly from the input buffer threads and the thread of the processing unit  14 .  
         [0037]     The output buffer  15  is the communication element between the processing unit  14  thread and the output module  16  thread. When filling of the output buffer  15  is requested, the processing unit  14  writes data into the output buffer  15  until the buffer is full. Then the processing unit waits i.e. does nothing or performs other tasks, until the output module  16  has read a data block from the output buffer  15 . Therefore the output module  16  determines the filling of the output buffer  15 , which in turn determines activation of the processing unit  14 .  
         [0038]     This thread-oriented processing results in a characteristic that is shown in  FIG. 3  for an exemplary audio data stream. In this example the output module has a time equivalent of 80 ms, i.e. works with 80 ms audio frames corresponding e.g. to 3840 audio samples at 48 kHz, and a decoding frame is sufficient for 20 ms audio reproduction. Thus, after an idle time dT of 80 ms the processing unit receives four processing calls c 1 , . . . , c 4  in short sequence.  FIG. 4   a  shows the resulting filling of the output buffer, which varies mainly between seven or eight and eleven-decode frames. Averaging the values as in  FIG. 4   b , and then low-pass filtering as in  FIG. 4   c  shows that on average there are almost ten decode frames in the buffer. The utilized conventional algorithm always tries to keep the output buffer full.  
         [0039]      FIG. 3  and  FIG. 4   a  show that the processing unit is called 4 times when a data block has been taken away from the FIFO, i.e. it is called as long as the output buffer is not full. This time behavior is typical for the thread-management of a non-RTOS.  
         [0040]     A processing unit for multiple multimedia stream data has to ensure lossless stream access and constant minimum delay processing. One example is a multi-input audio renderer for an MPEG-4 player.  
         [0041]     According to the invention, the solution is to approximate equidistant starting points for the processing by using a timer that can be set from the processing unit, and that is superordinate to the thread management of the OS. This is shown in  FIG. 5 . The system is similar to the previously described system of  FIG. 2 , except that a timer unit  21  is connected to the processing unit  14 . The timer unit is independent from the thread management, and particularly it is not part of the processing unit thread. The processing unit  14  sets the timer  21  with a value, e.g. after its signal processing, then starts the timer and goes into a wait mode, so that the microprocessor can do other things. When the timer reaches the end of the programmed time, it calls or “awakes” the processing module again. The processing module does its specific processing and sets the timer with a new value, so that the processing unit can wait for a specified time again, and so on. The timer value can in principle be calculated before or after the signal processing, but since this calculation is done in the processing unit, and the processing unit thread can be interrupted, an early calculation of the timer value is preferable. Then the timer can be started as early as possible, so that the probability for the timer to be active at a potential thread interruption is high.  
         [0042]     The timer value is generated from the saturation of the output FIFO module in the following way: The actual filling of the FIFO-buffer is measured. An average value of the filling over the last four measurement values is then calculated and low-pass filtered, e.g. by a 3 rd  order filter with normalized cut-off frequency of 0,1. This signal leads to the timer value with a clipped linear function of the form 
 
timerValue= k 1*fillingValue+ k 2 
 
 wherein k1 must be positive, and fillingValue in this case is the low-pass filtered average value of the filling measurement. The parameter k2 defines the minimum value when the timer is used, while k1 defines the sensitivity of the regulation. 
 
         [0043]     A generalized approach to find an equation that defines the control loop gain of the system is the following: first the range of adjustment of the regulation is individually limited, i.e. the buffer filling must be between minimum and maximum values as e.g. 2&lt;buffer filling&lt;11. Then a target filling is defined, which is eight blocks in this example. Though a linear equation is used here due to its simplicity, other types of equation are possible. In principle, the example can also be used when approximating a linear equation around the operating point being the target filling. Then the slope and the offset, corresponding to k1 and k2 of the above example, can be defined as follows: When timerValue is the value to which the timer shall be set, and fillingValue is the buffer filling value after averaging and low-pass filtering, for the lower limit of the operating range the timerValue shall be 0 for fillingValue being 2. Therefore: 
 
 k 2=−2 *k 1 
 
 Further, for the average buffer filling of eight the interval time of 20 ms shall result. Therefore: 
 
20= k 1*8−2 *k 1 
 
 which calculates to k1=10/3 and k2=−20/3. Finally, the timerValue is rounded to an integer: 
 
timerValue=integer(10/3*×−20/3+0.5) 
 
         [0044]     The function is clipped with respect to that it is used only when the measurement value ‘fillingValue’ is at least three and not more than eleven. This is shown in  FIG. 7 . When the measurement value is below three  74 , the timer is not used and the processing unit continues  710  with the next frame immediately. When the measurement value is above eleven  72 , the processing unit pauses for a defined time  73 , e.g. 1 ms, using a thread management function, before it takes another measurement value  71 . The OSs thread management however can interrupt the processing unit thread at any time. If the measurement value is within the defined range, it is averaged  75  and low-pass filtered  76  before it is input to the above-described equation  77 . The equation  77  results in a value that is used to set a timer  78  while the processing  79  of data blocks starts, e.g. audio data blocks. The timer then triggers  711  the next call of the processing unit thread. Therefore, the WaitForTimer( ) step  711  is not actually part of the thread process, but of the processing according to the invention.  
         [0045]     For example, k1 is set to 10/3 and k2 is set to −20/3. This results in an average output buffer filling with 8 frames of 20 ms each, as explained above. The effect of this regulation for the processing unit is shown in  FIG. 6 . The dots represent processing unit calls over time and are in approximately linear sequence, which means almost equidistant calls of the processing unit. As an important consequence of this precise time behavior, it is possible to better estimate the presentation time of the processed data, and to include for the estimation the buffer model of the output module. This is because the median saturation of the buffer is now well known, since it can be adjusted, and the processing time can be measured more exactly. With this knowledge, e.g. better audio/video (AV) synchronization and improved reaction on user interactivity for the processing algorithm can be achieved for AV reproduction.  
         [0046]      FIG. 8  shows the resulting behavior of a system according to the invention.  FIG. 8   a  shows the buffer filling, which is more flexible and on average lower than in  FIG. 4   a . This means that on average less data are in the output buffer. This effect becomes clearer when considering the average buffer filling, shown in  FIG. 8   b  averaged over four frames of 20 ms, and further averaging by low-pass filtering as shown in  FIG. 8   c .  FIG. 8   d  finally shows the timer values that are calculated from the low-pass filtered average filling values. When the output buffer is relatively full, e.g. at time t 81 , the low-pass filtered average filling value in  FIG. 8   c  is high and the timer value is high, due to the above-mentioned k1 being positive. Therefore the time between successive calls of the processing unit is relatively long, around or over 20 ms. When the low-pass filtered average filling value is low, the timer value is low, or the timer is even disabled because the timer value is below the specified minimum of three, e.g. at time t 82 , so that the processing unit processes more than one frame with each call.  
         [0047]      FIG. 9  shows the temporal behavior of the processing unit according to one embodiment of the invention. At time T 0  a timer value is calculated, the timer is set to that value and the frame processing starts. After a time of t 0  the OS terminates the processing unit thread. It is assumed that the available data have been processed within this time. The timer continues to run for a time of t P0 , and then calls the processing unit thread again at T 1 , so that the time difference since the previous call of the processing unit is T=t 0 +t P0 . At T 1  the processing unit thread becomes active again, measures the buffer filling, calculates a timer value as described above and sets the timer. Then it continues its frame processing, until thread management interrupts it after a time of t 11  and gives processing power to another process. The timer continues to run. After t P1  the thread management calls the processing unit thread again, in order to continue for an additional time of t 12  the processing of the data packets started at T 1 . When the next timer event appears at T 2 , the processing is still ongoing and continues for a further time of t D2 , but the timer event is stored. When the current thread is finished at T 2 +t D2 , it is immediately restarted again, and measures the buffer filling. Assuming that at this time the buffer is relatively empty, because it was continuously emptied, a lower timer value than before is calculated, corresponding to a shorter time T′ for the next timer period. This time T′ is equal or near T-t D2 , depending on the linear equation that deduces the timer value from the buffer filling, so that a substantially equidistant time raster is achieved for the start times of the processing unit thread.  
         [0048]     Although the start times of one or more particular threads can be outside the time raster, e.g. at T 2 +t D2 , the method according to the invention is suitable for reestablishing the raster. Further, the actual timer values are adapted to the current situation, and therefore the average time that the processing unit has can be adjusted. The raster time T, being the average value between successive calls of the processing unit, can be exactly adjusted to the application by proper selection of the parameters k1 and k2, and therefore the temporal behavior of the processing unit can be adapted to the temporal behavior of the output unit and the input units, which prevents blocking of the processing unit.  
         [0049]     In general, it is advantageous to select the raster time, i.e. the average time between successive calls of the processing unit, to be M milliseconds when the average output time interval is N*M milliseconds, with N being a positive integer larger than one.  
         [0050]     The invention comprises different possibilities for when to utilize the timer unit. The calculation of the timer value and the setting of the timer will preferably be done immediately after measuring the buffer filling, although in principle the measurement value can be stored and later be used for the calculation, e.g. within a start sequence or exit sequence of a thread.  
         [0051]     In one embodiment of the invention, the timer value is calculated always before processing a frame. In another embodiment, the timer value is calculated whenever the processing unit thread is called, as a start sequence of the thread. In yet another embodiment, the timer value is calculated only before the processing unit thread is terminated, as a part of an exit sequence of the thread. In one embodiment, the timer unit is set immediately after the calculation of the timer value. In another embodiment, the timer unit is set later, or always before terminating the processing unit thread, as a part of an exit sequence of the thread.  
         [0052]     The invention is particularly advantageous for implementing a multi-channel input audio renderer, e.g. for MPEG-4 or similar, in a multithreading environment, where the risk of processor overload is high.