/src/ghostpdl/jpegxr/init.c

Source


/*************************************************************************
*
* This software module was originally contributed by Microsoft
* Corporation in the course of development of the
* ITU-T T.832 | ISO/IEC 29199-2 ("JPEG XR") format standard for
* reference purposes and its performance may not have been optimized.
*
* This software module is an implementation of one or more
* tools as specified by the JPEG XR standard.
*
* ITU/ISO/IEC give You a royalty-free, worldwide, non-exclusive
* copyright license to copy, distribute, and make derivative works
* of this software module or modifications thereof for use in
* products claiming conformance to the JPEG XR standard as
* specified by ITU-T T.832 | ISO/IEC 29199-2.
*
* ITU/ISO/IEC give users the same free license to this software
* module or modifications thereof for research purposes and further
* ITU/ISO/IEC standardization.
*
* Those intending to use this software module in products are advised
* that its use may infringe existing patents. ITU/ISO/IEC have no
* liability for use of this software module or modifications thereof.
*
* Copyright is not released for products that do not conform to
* to the JPEG XR standard as specified by ITU-T T.832 |
* ISO/IEC 29199-2.
*
******** Section to be removed when the standard is published ************
*
* Assurance that the contributed software module can be used
* (1) in the ITU-T "T.JXR" | ISO/IEC 29199 ("JPEG XR") standard once the
* standard has been adopted; and
* (2) to develop the JPEG XR standard:
*
* Microsoft Corporation and any subsequent contributors to the development
* of this software grant ITU/ISO/IEC all rights necessary to include
* the originally developed software module or modifications thereof in the
* JPEG XR standard and to permit ITU/ISO/IEC to offer such a royalty-free,
* worldwide, non-exclusive copyright license to copy, distribute, and make
* derivative works of this software module or modifications thereof for
* use in products claiming conformance to the JPEG XR standard as
* specified by ITU-T T.832 | ISO/IEC 29199-2, and to the extent that
* such originally developed software module or portions of it are included
* in an ITU/ISO/IEC standard. To the extent that the original contributors
* may own patent rights that would be required to make, use, or sell the
* originally developed software module or portions thereof included in the
* ITU/ISO/IEC standard in a conforming product, the contributors will
* assure ITU/ISO/IEC that they are willing to negotiate licenses under
* reasonable and non-discriminatory terms and conditions with
* applicants throughout the world and in accordance with their patent
* rights declarations made to ITU/ISO/IEC (if any).
*
* Microsoft, any subsequent contributors, and ITU/ISO/IEC additionally
* gives You a free license to this software module or modifications
* thereof for the sole purpose of developing the JPEG XR standard.
*
******** end of section to be removed when the standard is published *****
*
* Microsoft Corporation retains full right to modify and use the code
* for its own purpose, to assign or donate the code to a third party,
* and to inhibit third parties from using the code for products that
* do not conform to the JPEG XR standard as specified by ITU-T T.832 |
* ISO/IEC 29199-2.
*
* This copyright notice must be included in all copies or derivative
* works.
*
* Copyright (c) ITU-T/ISO/IEC 2008, 2009.
***********************************************************************/

#ifdef _MSC_VER
#pragma comment (user,"$Id: init.c,v 1.12 2011-11-15 10:11:17 thor Exp $")
#endif

# include "jxr_priv.h"
# include <stdlib.h>
# include <assert.h>

const int _jxr_abslevel_index_delta[7] = { 1, 0, -1, -1, -1, -1, -1 };

static void clear_vlc_tables(jxr_image_t image)
{
    int idx;
    for (idx = 0 ; idx < AbsLevelInd_COUNT ; idx += 1) {
        image->vlc_table[idx].discriminant = 0;
        image->vlc_table[idx].discriminant2 = 0;
        image->vlc_table[idx].table = 0;
        image->vlc_table[idx].deltatable = 0;
        image->vlc_table[idx].delta2table = 0;
    }
}

static struct jxr_image* __make_jxr(jxr_alloc *alloc)
{
    struct jxr_image*image = (struct jxr_image*)jxr_calloc(alloc, 1, sizeof(struct jxr_image));
    int idx;
    if (image == NULL)
        return NULL;
    image->alloc = alloc;
    image->user_flags = 0;
    image->width1 = 0;
    image->height1 = 0;
    image->extended_width = 0;
    image->extended_height = 0;
    image->header_flags1 = 0;
    image->header_flags2 = 0x80; /* SHORT_HEADER_FLAG=1 */
    image->header_flags_fmt = 0;
    image->bands_present = 0; /* Default ALL bands present */
    image->num_channels = 0;
    image->tile_index_table = 0;
    image->tile_index_table_length = 0;
    image->tile_column_width = 0;
    image->tile_row_height = 0;
    image->primary = 1;

    clear_vlc_tables(image);

    for (idx = 0 ; idx < MAX_CHANNELS ; idx += 1) {
        image->strip[idx].up4 = 0;
        image->strip[idx].up3 = 0;
        image->strip[idx].up2 = 0;
        image->strip[idx].up1 = 0;
        image->strip[idx].cur = 0;
    }

    image->scaled_flag = 1;

    image->out_fun = 0;

    return image;
}

static int
make_mb_row_buffer_aux(jxr_image_t image, int ch, int format_scale, size_t block_count)
{
    int*data, *pred_dclp;
    size_t idx;

    image->mb_row_buffer[ch] = (struct macroblock_s*)jxr_calloc(image->alloc, block_count, sizeof(struct macroblock_s));
    if (image->mb_row_buffer[ch] == NULL)
        return -1;
    data = (int*)jxr_calloc(image->alloc, block_count*format_scale, sizeof(int));
    pred_dclp = (int*)jxr_calloc(image->alloc, block_count*7, sizeof(int));
    if (data == NULL || pred_dclp == NULL) {
        jxr_free(image->alloc, data);
        jxr_free(image->alloc, pred_dclp);
        return -1;
    }

    for (idx = 0 ; idx < block_count ; idx += 1) {
        image->mb_row_buffer[ch][idx].data = data + format_scale*idx;
        /* 7 (used as mutilpier) = 1 DC + 3 top LP + 3 left LP coefficients used for prediction */
        image->mb_row_buffer[ch][idx].pred_dclp = pred_dclp + 7*idx;
    }

    return 0;
}

static int make_mb_row_buffer(jxr_image_t image, unsigned use_height)
{
    size_t block_count = EXTENDED_WIDTH_BLOCKS(image) * use_height;
    size_t idx;
    int format_scale;
    int ch;

    if (make_mb_row_buffer_aux(image, 0, 256, block_count))
        return -1;

    format_scale = 256;
    if (image->use_clr_fmt == 2 /* YUV422 */) {
        format_scale = 16 + 8*15;
    } else if (image->use_clr_fmt == 1 /* YUV420 */) {
        format_scale = 16 + 4*15;
    }

    for (ch = 1 ; ch < image->num_channels ; ch += 1) {
        if (make_mb_row_buffer_aux(image, ch, format_scale, block_count))
            return -1;
    }
    return 0;
}

/*
* Allocate the macroblock strip store. Each macroblock points to 256
* values that are either the 256 pixel values, or the DC, LP and HP
* coefficients.
*
* DC/LP/HP arrangement -
* The first word is the DC.
* The next 15 are the LP coefficients.
* The remaining 240 are HP coefficients.
*/
int _jxr_make_mbstore(jxr_image_t image, int up4_flag)
{
    int ch;

    assert(image->strip[0].up4 == 0);
    assert(image->strip[0].up3 == 0);
    assert(image->strip[0].up2 == 0);
    assert(image->strip[0].up1 == 0);
    assert(image->strip[0].cur == 0);

    assert(image->num_channels > 0);

    if (EXTENDED_WIDTH_BLOCKS(image) == 0 || EXTENDED_HEIGHT_BLOCKS(image) == 0)
        return -1;

    for (ch = 0 ; ch < image->num_channels ; ch += 1) {
        size_t idx;
        if (up4_flag)
        {
            image->strip[ch].up4 = (struct macroblock_s*)
            jxr_calloc(image->alloc, EXTENDED_WIDTH_BLOCKS(image), sizeof(struct macroblock_s));
            if (image->strip[ch].up4 == NULL)
                return -1;
        }
        image->strip[ch].up3 = (struct macroblock_s*)
            jxr_calloc(image->alloc, EXTENDED_WIDTH_BLOCKS(image), sizeof(struct macroblock_s));
        if (image->strip[ch].up3 == NULL)
            return -1;
        image->strip[ch].up2 = (struct macroblock_s*)
            jxr_calloc(image->alloc, EXTENDED_WIDTH_BLOCKS(image), sizeof(struct macroblock_s));
        if (image->strip[ch].up2 == NULL)
            return -1;
        image->strip[ch].up1 = (struct macroblock_s*)
            jxr_calloc(image->alloc, EXTENDED_WIDTH_BLOCKS(image), sizeof(struct macroblock_s));
        if (image->strip[ch].up1 == NULL)
            return -1;
        image->strip[ch].cur = (struct macroblock_s*)
            jxr_calloc(image->alloc, EXTENDED_WIDTH_BLOCKS(image), sizeof(struct macroblock_s));
        if (image->strip[ch].cur == NULL)
            return -1;

        if (up4_flag) {
            image->strip[ch].up4[0].data = (int*)jxr_calloc(image->alloc, 256 * EXTENDED_WIDTH_BLOCKS(image), sizeof(int));
            if (image->strip[ch].up4[0].data == NULL)
                return -1;
            for (idx = 1 ; idx < EXTENDED_WIDTH_BLOCKS(image) ; idx += 1)
                image->strip[ch].up4[idx].data = image->strip[ch].up4[idx-1].data + 256;
        }
        image->strip[ch].up3[0].data = (int*)jxr_calloc(image->alloc, 256 * EXTENDED_WIDTH_BLOCKS(image), sizeof(int));
        if (image->strip[ch].up3[0].data == NULL)
            return -1;
        for (idx = 1 ; idx < EXTENDED_WIDTH_BLOCKS(image) ; idx += 1)
            image->strip[ch].up3[idx].data = image->strip[ch].up3[idx-1].data + 256;

        image->strip[ch].up2[0].data = (int*)jxr_calloc(image->alloc, 256 * EXTENDED_WIDTH_BLOCKS(image), sizeof(int));
        if (image->strip[ch].up2[0].data == NULL)
            return -1;
        for (idx = 1 ; idx < EXTENDED_WIDTH_BLOCKS(image) ; idx += 1)
            image->strip[ch].up2[idx].data = image->strip[ch].up2[idx-1].data + 256;

        image->strip[ch].up1[0].data = (int*)jxr_calloc(image->alloc, 256 * EXTENDED_WIDTH_BLOCKS(image), sizeof(int));
        if (image->strip[ch].up1[0].data == NULL)
            return -1;
        for (idx = 1 ; idx < EXTENDED_WIDTH_BLOCKS(image) ; idx += 1)
            image->strip[ch].up1[idx].data = image->strip[ch].up1[idx-1].data + 256;

        image->strip[ch].cur[0].data = (int*)jxr_calloc(image->alloc, 256 * EXTENDED_WIDTH_BLOCKS(image), sizeof(int));
        if (image->strip[ch].cur[0].data == NULL)
            return -1;
        for (idx = 1 ; idx < EXTENDED_WIDTH_BLOCKS(image) ; idx += 1)
            image->strip[ch].cur[idx].data = image->strip[ch].cur[idx-1].data + 256;

        if (up4_flag) {
            image->strip[ch].up4[0].pred_dclp = (int*)jxr_calloc(image->alloc, 7*EXTENDED_WIDTH_BLOCKS(image), sizeof(int));
            if (image->strip[ch].up4[0].pred_dclp == NULL)
                return -1;
            for (idx = 1 ; idx < EXTENDED_WIDTH_BLOCKS(image) ; idx += 1)
                image->strip[ch].up4[idx].pred_dclp = image->strip[ch].up4[idx-1].pred_dclp + 7;
        }

        image->strip[ch].up3[0].pred_dclp = (int*)jxr_calloc(image->alloc, 7*EXTENDED_WIDTH_BLOCKS(image), sizeof(int));
        if (image->strip[ch].up3[0].pred_dclp == NULL)
            return -1;
        for (idx = 1 ; idx < EXTENDED_WIDTH_BLOCKS(image) ; idx += 1)
            image->strip[ch].up3[idx].pred_dclp = image->strip[ch].up3[idx-1].pred_dclp + 7;

        image->strip[ch].up2[0].pred_dclp = (int*)jxr_calloc(image->alloc, 7*EXTENDED_WIDTH_BLOCKS(image), sizeof(int));
        if (image->strip[ch].up2[0].pred_dclp == NULL)
            return -1;
        for (idx = 1 ; idx < EXTENDED_WIDTH_BLOCKS(image) ; idx += 1)
            image->strip[ch].up2[idx].pred_dclp = image->strip[ch].up2[idx-1].pred_dclp + 7;

        image->strip[ch].up1[0].pred_dclp = (int*)jxr_calloc(image->alloc, 7*EXTENDED_WIDTH_BLOCKS(image), sizeof(int));
        if (image->strip[ch].up1[0].pred_dclp == NULL)
            return -1;
        for (idx = 1 ; idx < EXTENDED_WIDTH_BLOCKS(image) ; idx += 1)
            image->strip[ch].up1[idx].pred_dclp = image->strip[ch].up1[idx-1].pred_dclp + 7;

        image->strip[ch].cur[0].pred_dclp = (int*)jxr_calloc(image->alloc, 7*EXTENDED_WIDTH_BLOCKS(image), sizeof(int));
        if (image->strip[ch].cur[0].pred_dclp == NULL)
            return -1;
        for (idx = 1 ; idx < EXTENDED_WIDTH_BLOCKS(image) ; idx += 1)
            image->strip[ch].cur[idx].pred_dclp = image->strip[ch].cur[idx-1].pred_dclp + 7;

        if(ch!= 0)
        {
            if(image->use_clr_fmt == 2 || image->use_clr_fmt == 1) /* 422 or 420 */
            {
                image->strip[ch].upsample_memory_x = (int*)jxr_calloc(image->alloc, 16, sizeof(int));
                if (image->strip[ch].upsample_memory_x == NULL)
                    return -1;
            }

            if(image->use_clr_fmt == 1)/* 420 */
            {
                image->strip[ch].upsample_memory_y = (int*)jxr_calloc(image->alloc, 8*EXTENDED_WIDTH_BLOCKS(image), sizeof(int));
                if (image->strip[ch].upsample_memory_y == NULL)
                    return -1;
            }
        }
        
    }

    /* If there is tiling (in columns) then allocate a tile buffer
    that can hold an entire row of tiles. */
    if (FREQUENCY_MODE_CODESTREAM_FLAG(image)) { /* FREQUENCY MODE */

        if (make_mb_row_buffer(image, EXTENDED_HEIGHT_BLOCKS(image)))
            return -1;

    } else { /* SPATIAL */
        if (INDEXTABLE_PRESENT_FLAG(image)) { 
            /* This means that the tiling flag is used */
            unsigned max_tile_height = 0;
            unsigned idx;
            int format_scale;
            int ch;
            for (idx = 0 ; idx < image->tile_rows ; idx += 1) {
                if (image->tile_row_height[idx] > max_tile_height)
                    max_tile_height = image->tile_row_height[idx];
            }

            if (make_mb_row_buffer(image, max_tile_height))
                return -1;

            /* Save enough context MBs for 4 rows of
            macroblocks. */

            format_scale = 256;
            if (image->use_clr_fmt == 2 /* YUV422 */) {
                format_scale = 16 + 8*15;
            } else if (image->use_clr_fmt == 1 /* YUV420 */) {
                format_scale = 16 + 4*15;
            }

            for (ch = 0 ; ch < image->num_channels ; ch += 1) {
                int count = (ch==0)? 256 : format_scale;
                image->mb_row_context[ch] = (struct macroblock_s*)
                    jxr_calloc(image->alloc, 4*EXTENDED_WIDTH_BLOCKS(image), sizeof(struct macroblock_s));
                if (image->mb_row_context[ch] == NULL)
                    return -1;
                image->mb_row_context[ch][0].data = (int*)
                    jxr_calloc(image->alloc, 4*EXTENDED_WIDTH_BLOCKS(image)*count, sizeof(int));
                if (image->mb_row_context[ch][0].data == NULL)
                    return -1;
                for (idx = 1 ; idx < 4*EXTENDED_WIDTH_BLOCKS(image) ; idx += 1)
                    image->mb_row_context[ch][idx].data = image->mb_row_context[ch][idx-1].data+count;
            }

        }
    }

    /* since CBP processing is done at each row, need to save contexts is multiple tile columns */
    image->model_hp_buffer = 0;
    image->hp_cbp_model_buffer = 0;
    if (image->tile_columns > 1) {
        image->model_hp_buffer = (struct model_s*)
            jxr_calloc(image->alloc, image->tile_columns, sizeof(struct model_s));
        if (image->model_hp_buffer == NULL)
            return -1;
        image->hp_cbp_model_buffer = (struct cbp_model_s*)
            jxr_calloc(image->alloc, image->tile_columns, sizeof(struct cbp_model_s));
        if (image->hp_cbp_model_buffer == NULL)
            return -1;
    }

    image->cur_my = -1;

    return 0;
}

jxr_image_t jxr_create_input_alloc(jxr_alloc *alloc)
{
    struct jxr_image*image = __make_jxr(alloc);

    return image;
}

jxr_image_t jxr_create_input(void)
{
    return jxr_create_input_alloc(NULL);}

jxr_image_t jxr_create_image(int width, int height, unsigned char * windowing)
{
    return jxr_create_image_alloc(NULL, width, height, windowing);
}

jxr_image_t jxr_create_image_alloc(jxr_alloc *alloc, int width, int height, unsigned char * windowing)
{
    struct jxr_image*image;

    if (width == 0 || height == 0)
        return 0;

    image = __make_jxr(alloc);
    if (image == NULL)
        return 0;

    if (windowing[0] == 1) {
      unsigned extra_width  = (-(width + windowing[2]+windowing[4])) & 0x0f;
      unsigned extra_height = (-(height +windowing[1]+windowing[3])) & 0x0f;

      /*
      ** fixup the bottom and right borders such that the nominal image
      ** dimensions are divisible by 16
      */

      if (extra_width || extra_height)
        fprintf(stderr,"WARNING: enlarging the window borders to align the extended size to 16 pixel boundaries\n");

      windowing[4] += extra_width;
      windowing[3] += extra_height;

      assert(((width+windowing[2]+windowing[4]) & 0x0f) == 0);
      assert(((height+windowing[1]+windowing[3]) & 0x0f) == 0);
    }
    else {
        windowing[1] = windowing[2] = 0;
        windowing[3] = (((height + 15) >> 4) << 4) - height;
        windowing[4] = (((width + 15) >> 4) << 4) - width;
    }

    if (windowing[1] >= 64 || windowing[2] >= 64 || windowing[3] >= 64 || windowing[4] >= 64) {
      fprintf(stderr,"Window borders are larger or equal than 64 pixels which is unsupported\n");
      return 0;
    }

    image->width1 = width-1;
    image->height1 = height-1;
    image->extended_width = image->width1 + 1 + windowing[2] + windowing[4];
    image->extended_height = image->height1 + 1 + windowing[1] + windowing[3];

    image->dc_frame_uniform = 1;
    image->lp_frame_uniform = 1;
    image->lp_use_dc_qp = 0;
    image->num_lp_qps = 1;
    image->hp_use_lp_qp = 0;
    image->hp_frame_uniform = 1;
    image->num_hp_qps = 1;

    image->window_extra_top = windowing[1];
    image->window_extra_left = windowing[2];
    image->window_extra_bottom = windowing[3];
    image->window_extra_right = windowing[4];

    return image;
}

void jxr_flag_SKIP_HP_DATA(jxr_image_t image, int flag)
{
    if (flag)
        image->user_flags |= 0x0001;
    else
        image->user_flags &= ~0x0001;
}

void jxr_flag_SKIP_FLEX_DATA(jxr_image_t image, int flag)
{
    if (flag)
        image->user_flags |= 0x0002;
    else
        image->user_flags &= ~0x0002;
}

void jxr_destroy(jxr_image_t image)
{
    int idx, plane_idx = 1;
    if(image == NULL)
        return;

    if (ALPHACHANNEL_FLAG(image))
        plane_idx = 2;
    
    for (; plane_idx > 0; plane_idx --) {
        jxr_image_t plane = (plane_idx == 1 ? image : image->alpha);

        for (idx = 0 ; idx < plane->num_channels ; idx += 1) {
            if (plane->strip[idx].up4) {
              jxr_free(image->alloc, plane->strip[idx].up4[0].pred_dclp);
              jxr_free(image->alloc, plane->strip[idx].up4[0].data);
              jxr_free(image->alloc, plane->strip[idx].up4);
            }
            if (plane->strip[idx].up3) {
              jxr_free(image->alloc, plane->strip[idx].up3[0].pred_dclp);
              jxr_free(image->alloc, plane->strip[idx].up3[0].data);
              jxr_free(image->alloc, plane->strip[idx].up3);
            }
            if (plane->strip[idx].up2) {
              jxr_free(image->alloc, plane->strip[idx].up2[0].pred_dclp);
              jxr_free(image->alloc, plane->strip[idx].up2[0].data);
              jxr_free(image->alloc, plane->strip[idx].up2);
            }
            if (plane->strip[idx].up1) {
              jxr_free(image->alloc, plane->strip[idx].up1[0].pred_dclp);
              jxr_free(image->alloc, plane->strip[idx].up1[0].data);
              jxr_free(image->alloc, plane->strip[idx].up1);
            }
            if (plane->strip[idx].cur) {
              jxr_free(image->alloc, plane->strip[idx].cur[0].pred_dclp);
              jxr_free(image->alloc, plane->strip[idx].cur[0].data);
              jxr_free(image->alloc, plane->strip[idx].cur);
            }
            if(plane->strip[idx].upsample_memory_x)
                jxr_free(image->alloc, plane->strip[idx].upsample_memory_x);
            if(plane->strip[idx].upsample_memory_y)
                jxr_free(image->alloc, plane->strip[idx].upsample_memory_y);

        }

        for (idx = 0 ; idx < plane->num_channels ; idx += 1) {
            if (plane->mb_row_buffer[idx]) {
                jxr_free(image->alloc, plane->mb_row_buffer[idx][0].data);
                jxr_free(image->alloc, plane->mb_row_buffer[idx]);
            }

            if (plane->mb_row_context[idx]) {
                jxr_free(image->alloc, plane->mb_row_context[idx][0].data);
                jxr_free(image->alloc, plane->mb_row_context[idx]);
            }
        }

        if (plane->model_hp_buffer) {
            jxr_free(image->alloc, plane->model_hp_buffer);
        }

        if (plane->hp_cbp_model_buffer) {
            jxr_free(image->alloc, plane->hp_cbp_model_buffer);
        }

        if(plane_idx == 1){
            if (plane->tile_index_table)
              jxr_free(image->alloc, plane->tile_index_table);
            if (plane->tile_column_width)
              jxr_free(image->alloc, plane->tile_column_width);
            if (plane->tile_row_height)
              jxr_free(image->alloc, plane->tile_row_height);
        }
        jxr_free(image->alloc, plane);
    }
}

void *jxr_malloc(jxr_alloc *alloc, size_t z)
{
    if (alloc == NULL)
        return malloc(z);
    return alloc->malloc(alloc->handle, z);
}

void *jxr_calloc(jxr_alloc *alloc, size_t z, size_t n)
{
    if (alloc == NULL)
        return calloc(z, n);
    return alloc->calloc(alloc->handle, z, n);
}

void *jxr_realloc(jxr_alloc *alloc, void *ptr, size_t z)
{
    if (alloc == NULL)
        return realloc(ptr, z);
    return alloc->realloc(alloc->handle, ptr, z);
}

void jxr_free(jxr_alloc *alloc, void *ptr)
{
    if (alloc == NULL)
    {
        free(ptr);
        return;
    }
    alloc->free(alloc->handle, ptr);
}

/*
* $Log: init.c,v $
* Revision 1.12  2011-11-15 10:11:17  thor
* Bumped to release 1.30.
*
* Revision 1.11  2011-11-11 17:13:50  thor
* Fixed a memory bug, fixed padding channel on encoding bug.
* Fixed window sizes (again).
*
* Revision 1.10  2011-11-08 20:17:29  thor
* Merged a couple of fixes from the JNB.
*
* Revision 1.9  2011-04-28 08:45:43  thor
* Fixed compiler warnings, ported to gcc 4.4, removed obsolete files.
*
* Revision 1.8  2010-05-22 22:14:35  thor
* Fixed memory leaks in the TIFF parser.
*
* Revision 1.7  2010-03-31 07:50:58  thor
* Replaced by the latest MS version.
*
* Revision 1.25 2009/05/29 12:00:00 microsoft
* Reference Software v1.6 updates.
*
* Revision 1.24 2009/04/13 12:00:00 microsoft
* Reference Software v1.5 updates.
*
* Revision 1.23 2008/03/13 21:23:27 steve
* Add pipeline step for YUV420.
*
* Revision 1.22 2008/03/05 06:58:10 gus
* *** empty log message ***
*
* Revision 1.21 2008/02/28 18:50:31 steve
* Portability fixes.
*
* Revision 1.20 2008/02/26 23:52:44 steve
* Remove ident for MS compilers.
*
* Revision 1.19 2008/01/04 17:07:35 steve
* API interface for setting QP values.
*
* Revision 1.18 2007/11/26 01:47:15 steve
* Add copyright notices per MS request.
*
* Revision 1.17 2007/11/22 19:02:05 steve
* More fixes of color plane buffer sizes.
*
* Revision 1.16 2007/11/21 23:26:14 steve
* make all strip buffers store MB data.
*
* Revision 1.15 2007/11/21 00:34:30 steve
* Rework spatial mode tile macroblock shuffling.
*
* Revision 1.14 2007/11/15 17:44:13 steve
* Frequency mode color support.
*
* Revision 1.13 2007/11/14 23:56:17 steve
* Fix TILE ordering, using seeks, for FREQUENCY mode.
*
* Revision 1.12 2007/11/12 23:21:54 steve
* Infrastructure for frequency mode ordering.
*
* Revision 1.11 2007/11/08 02:52:32 steve
* Some progress in some encoding infrastructure.
*
* Revision 1.10 2007/11/05 02:01:12 steve
* Add support for mixed row/column tiles.
*
* Revision 1.9 2007/11/01 21:09:40 steve
* Multiple rows of tiles.
*
* Revision 1.8 2007/10/30 21:32:46 steve
* Support for multiple tile columns.
*
* Revision 1.7 2007/09/08 01:01:43 steve
* YUV444 color parses properly.
*
* Revision 1.6 2007/09/04 19:10:46 steve
* Finish level1 overlap filtering.
*
* Revision 1.5 2007/08/15 01:54:11 steve
* Add level2 filter to decoder.
*
* Revision 1.4 2007/08/04 00:15:31 steve
* Allow width/height of 1 pixel.
*
* Revision 1.3 2007/07/21 00:25:48 steve
* snapshot 2007 07 20
*
* Revision 1.2 2007/06/28 20:03:11 steve
* LP processing seems to be OK now.
*
* Revision 1.1 2007/06/06 17:19:12 steve
* Introduce to CVS.
*
*/


Coverage Report

Created: 2026-09-14 07:34