Class EBCOTRateAllocator

  • All Implemented Interfaces:
    ImgData

    public class EBCOTRateAllocator
    extends PostCompRateAllocator
    This implements the EBCOT post compression rate allocation algorithm. This algorithm finds the most suitable truncation points for the set of code-blocks, for each layer target bitrate. It works by first collecting the rate distortion info from all code-blocks, in all tiles and all components, and then running the rate-allocation on the whole image at once, for each layer.

    This implementation also provides some timing features. They can be enabled by setting the 'DO_TIMING' constant of this class to true and recompiling. The timing uses the 'System.currentTimeMillis()' Java API call, which returns wall clock time, not the actual CPU time used. The timing results will be printed on the message output. Since the times reported are wall clock times and not CPU usage times they can not be added to find the total used time (i.e. some time might be counted in several places). When timing is disabled ('DO_TIMING' is false) there is no penalty if the compiler performs some basic optimizations. Even if not the penalty should be negligeable.

    See Also:
    PostCompRateAllocator, CodedCBlkDataSrcEnc, CodestreamWriter
    • Method Detail

      • writeResLyCompPos

        public void writeResLyCompPos​(int t,
                                      int rs,
                                      int re,
                                      int cs,
                                      int ce,
                                      int[][] lys,
                                      int lye)
                               throws IOException
        Write a piece of bit stream according to the RES_LY_COMP_POS_PROG progression mode and between given bounds
        Parameters:
        t - Tile index.
        rs - First resolution level index.
        re - Last resolution level index.
        cs - First component index.
        ce - Last component index.
        lys - First layer index for each component and resolution.
        lye - Index of the last layer.
        Throws:
        IOException
      • writeLyResCompPos

        public void writeLyResCompPos​(int t,
                                      int rs,
                                      int re,
                                      int cs,
                                      int ce,
                                      int[][] lys,
                                      int lye)
                               throws IOException
        Write a piece of bit stream according to the LY_RES_COMP_POS_PROG progression mode and between given bounds
        Parameters:
        t - Tile index.
        rs - First resolution level index.
        re - Last resolution level index.
        cs - First component index.
        ce - Last component index.
        lys - First layer index for each component and resolution.
        lye - Index of the last layer.
        Throws:
        IOException
      • writePosCompResLy

        public void writePosCompResLy​(int t,
                                      int rs,
                                      int re,
                                      int cs,
                                      int ce,
                                      int[][] lys,
                                      int lye)
                               throws IOException
        Write a piece of bit stream according to the COMP_POS_RES_LY_PROG progression mode and between given bounds
        Parameters:
        t - Tile index.
        rs - First resolution level index.
        re - Last resolution level index.
        cs - First component index.
        ce - Last component index.
        lys - First layer index for each component and resolution.
        lye - Index of the last layer.
        Throws:
        IOException
      • writeCompPosResLy

        public void writeCompPosResLy​(int t,
                                      int rs,
                                      int re,
                                      int cs,
                                      int ce,
                                      int[][] lys,
                                      int lye)
                               throws IOException
        Write a piece of bit stream according to the COMP_POS_RES_LY_PROG progression mode and between given bounds
        Parameters:
        t - Tile index.
        rs - First resolution level index.
        re - Last resolution level index.
        cs - First component index.
        ce - Last component index.
        lys - First layer index for each component and resolution.
        lye - Index of the last layer.
        Throws:
        IOException
      • writeResPosCompLy

        public void writeResPosCompLy​(int t,
                                      int rs,
                                      int re,
                                      int cs,
                                      int ce,
                                      int[][] lys,
                                      int lye)
                               throws IOException
        Write a piece of bit stream according to the RES_POS_COMP_LY_PROG progression mode and between given bounds
        Parameters:
        t - Tile index.
        rs - First resolution level index.
        re - Last resolution level index.
        cs - First component index.
        ce - Last component index.
        lys - First layer index for each component and resolution.
        lye - Last layer index.
        Throws:
        IOException