root/morphix/trunk/cloop/advancecomp-1.9_create_compressed_fs/mngex.cc

/*
 * This file is part of the AdvanceSCAN project.
 *
 * Copyright (C) 2002, 2003 Andrea Mazzoleni
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details. 
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "portable.h"

#include "mngex.h"

#include "lib/mng.h"
#include "lib/endianrw.h"

#include <cassert>

#include <iostream>
#include <iomanip>

using namespace std;

static bool mng_write_reduce(adv_mng_write* mng, data_ptr& out_ptr, unsigned& out_scanline, unsigned char* ovr_ptr, unsigned* ovr_used, unsigned char* img_ptr, unsigned img_scanline)
{
        unsigned char col_ptr[256*3];
        unsigned col_mapped[256];
        unsigned col_count;
        unsigned i,j,k;
        unsigned char* new_ptr;
        unsigned new_scanline;

        /* build the new palette */
        col_count = 0;
        for(i=0;i<mng->height;++i) {
                unsigned char* p0 = img_ptr + i * img_scanline;
                for(j=0;j<mng->width;++j) {
                        for(k=0;k<col_count;++k) {
                                if (col_ptr[k*3] == p0[0] && col_ptr[k*3+1] == p0[1] && col_ptr[k*3+2] == p0[2])
                                        break;
                        }
                        if (k == col_count) {
                                if (col_count == 256)
                                        return false; /* too many colors */
                                col_ptr[col_count*3] = p0[0];
                                col_ptr[col_count*3+1] = p0[1];
                                col_ptr[col_count*3+2] = p0[2];
                                ++col_count;
                        }
                        p0 += 3;
                }
        }

        for(i=0;i<256;++i) {
                ovr_used[i] = 0;
                col_mapped[i] = 0;
        }
        memcpy(ovr_ptr, mng->pal_ptr, 256*3);

        /* map colors already present in the old palette */
        for(i=0;i<col_count;++i) {
                for(k=0;k<256;++k) {
                        if (!ovr_used[k] && ovr_ptr[k*3]==col_ptr[i*3] && ovr_ptr[k*3+1]==col_ptr[i*3+1] && ovr_ptr[k*3+2]==col_ptr[i*3+2])
                                break;
                }
                if (k<256) {
                        ovr_used[k] = 1;
                        col_mapped[i] = 1;
                }
        }

        /* map colors not present in the old palette */
        for(i=0;i<col_count;++i) {
                if (!col_mapped[i]) {
                        /* search the first free space */
                        for(k=0;k<256;++k)
                                if (!ovr_used[k])
                                        break;
                        ovr_used[k] = 1;
                        ovr_ptr[k*3] = col_ptr[i*3];
                        ovr_ptr[k*3+1] = col_ptr[i*3+1];
                        ovr_ptr[k*3+2] = col_ptr[i*3+2];
                }
        }

        /* create the new bitmap */
        new_scanline = mng->width;
        new_ptr = data_alloc(mng->height * new_scanline);
        for(i=0;i<mng->height;++i) {
                unsigned char* p0 = new_ptr + i*new_scanline;
                unsigned char* p1 = img_ptr + i*img_scanline;
                for(j=0;j<mng->width;++j) {
                        for(k=0;;++k)
                                if (ovr_ptr[k*3]==p1[0] && ovr_ptr[k*3+1]==p1[1] && ovr_ptr[k*3+2]==p1[2])
                                        break;
                        *p0 = k;
                        ++p0;
                        p1 += 3;
                }
        }

        out_ptr = new_ptr;
        out_scanline = new_scanline;

        return true;
}

static void mng_write_expand(adv_mng_write* mng, data_ptr& out_ptr, unsigned& out_scanline, const unsigned char* img_ptr, unsigned img_scanline, unsigned char* pal_ptr)
{
        unsigned char* new_ptr;
        unsigned new_scanline;
        unsigned i,j;

        /* create the new bitmap */
        new_scanline = mng->width * 3;
        new_ptr = data_alloc(mng->height * new_scanline);

        for(i=0;i<mng->height;++i) {
                unsigned char* p0 = new_ptr + i*new_scanline;
                const unsigned char* p1 = img_ptr + i*img_scanline;
                for(j=0;j<mng->width;++j) {
                        unsigned k = 3 * *p1;
                        p0[0] = pal_ptr[k];
                        p0[1] = pal_ptr[k+1];
                        p0[2] = pal_ptr[k+2];
                        p0 += 3;
                        ++p1;
                }
        }

        out_ptr = new_ptr;
        out_scanline = new_scanline;
}

void mng_write_header(adv_mng_write* mng, adv_fz* f, unsigned* fc, unsigned width, unsigned height, unsigned frequency, int scroll_x, int scroll_y, unsigned scroll_width, unsigned scroll_height)
{
        unsigned simplicity;
        unsigned char mhdr[28];

        if (mng_write_signature(f, fc) != 0) {
                throw error_png();
        }

        switch (mng->type) {
        case mng_vlc :
                simplicity = (1 << 0) /* Enable flags */
                        | (1 << 6); /* Enable flags */
                break;
        case mng_lc :
                simplicity = (1 << 0) /* Enable flags */
                        | (1 << 1) /* Basic features */
                        | (1 << 6); /* Enable flags */
                break;
        default:
        case mng_std :
                simplicity = (1 << 0) /* Enable flags */
                        | (1 << 1) /* Basic features */
                        | (1 << 2) /* Extended features */
                        | (1 << 5) /* Delta PNG */
                        | (1 << 6) /* Enable flags */
                        | (1 << 9); /* Object buffers must be stored */
                break;
        }

        be_uint32_write(mhdr + 0, width); /* width */
        be_uint32_write(mhdr + 4, height); /* height */
        be_uint32_write(mhdr + 8, frequency ); /* ticks per second */
        be_uint32_write(mhdr + 12, 0 ); /* nominal layer count */
        be_uint32_write(mhdr + 16, 0 ); /* nominal frame count */
        be_uint32_write(mhdr + 20, 0 ); /* nominal play time */
        be_uint32_write(mhdr + 24, simplicity); /* simplicity profile */

        if (png_write_chunk(f, MNG_CN_MHDR, mhdr, sizeof(mhdr), fc) != 0) {
                throw error_png();
        }

        mng->first = 1;

        mng->width = width;
        mng->height = height;
        mng->pixel = 0;
        mng->line = 0;

        mng->scroll_x = scroll_x;
        mng->scroll_y = scroll_y;
        mng->scroll_width = scroll_width;
        mng->scroll_height = scroll_height;

        mng->scroll_ptr = 0;

        mng->pal_size = 0;

        mng->tick = 1;

        mng->has_header = 1;
}

static bool row_equal(adv_mng_write* mng, unsigned y, unsigned char* img_ptr, unsigned img_scanline)
{
        unsigned char* p0;
        unsigned char* p1;

        p0 = mng->current_ptr + y * mng->line;
        p1 = img_ptr + y * img_scanline;

        return memcmp(p0, p1, mng->width * mng->pixel) == 0;
}

static bool col_equal(adv_mng_write* mng, unsigned x, unsigned char* img_ptr, unsigned img_scanline) {
        unsigned char* p0;
        unsigned char* p1;
        unsigned i;

        p0 = mng->current_ptr + x * mng->pixel;
        p1 = img_ptr + x * mng->pixel;

        if (mng->pixel == 1) {
                for(i=0;i<mng->height;++i) {
                        if (p0[0] != p1[0])
                                return false;
                        p0 += mng->line;
                        p1 += img_scanline;
                }
        } else {
                for(i=0;i<mng->height;++i) {
                        if (p0[0] != p1[0] || p0[1] != p1[1] || p0[2] != p1[2])
                                return false;
                        p0 += mng->line;
                        p1 += img_scanline;
                }
        }

        return true;
}

static void compute_image_range(adv_mng_write* mng, unsigned* out_x, unsigned* out_y, unsigned* out_dx, unsigned* out_dy, unsigned char* img_ptr, unsigned img_scanline)
{
        unsigned x;
        unsigned dx;
        unsigned y;
        unsigned dy;

        x = 0;
        while (x < mng->width && col_equal(mng, x, img_ptr, img_scanline))
                ++x;

        dx = mng->width - x;
        while (dx > 0 && col_equal(mng, x + dx - 1, img_ptr, img_scanline))
                --dx;

        y = 0;
        while (y < mng->height && row_equal(mng, y, img_ptr, img_scanline))
                ++y;

        dy = mng->height - y;
        while (dy > 0 && row_equal(mng, y + dy - 1, img_ptr, img_scanline))
                --dy;

        *out_x = x;
        *out_y = y;
        *out_dx = dx;
        *out_dy = dy;
}

static void mng_write_store(adv_mng_write* mng, unsigned char* img_ptr, unsigned img_scanline, unsigned char* pal_ptr, unsigned pal_size)
{
        unsigned i;

        if (pal_size) {
                memcpy(mng->pal_ptr, pal_ptr, pal_size);
                memset(mng->pal_ptr + pal_size, 0, 256*3 - pal_size);
                if (pal_size > mng->pal_size)
                        mng->pal_size = pal_size;
        }

        for(i=0;i<mng->height;++i) {
                memcpy( &mng->current_ptr[i * mng->line], &img_ptr[i * img_scanline], mng->width * mng->pixel);
        }
}

static void mng_write_first(adv_mng_write* mng, adv_fz* f, unsigned* fc)
{
        unsigned char defi[12];
        unsigned defi_size;
        unsigned char ihdr[13];
        data_ptr z_ptr;
        unsigned z_size;

        if (mng->type == mng_std) {
                be_uint16_write(defi + 0, 1); /* object id */
                defi[2] = 0; /* visible */
                defi[3] = 1; /* concrete */
                if (mng->scroll_x!=0 || mng->scroll_y!=0) {
                        be_uint32_write(defi + 4, - mng->scroll_x);
                        be_uint32_write(defi + 8, - mng->scroll_y);
                        defi_size = 12;
                } else
                        defi_size = 4;
                if (png_write_chunk(f, MNG_CN_DEFI, defi, defi_size, fc) != 0) {
                        throw error_png();
                }
        }

        be_uint32_write(ihdr + 0, mng->width + mng->scroll_width);
        be_uint32_write(ihdr + 4, mng->height + mng->scroll_height);
        ihdr[8] = 8; /* bit depth */
        if (mng->pixel == 1)
                ihdr[9] = 3; /* color type */
        else 
                ihdr[9] = 2; /* color type */
        ihdr[10] = 0; /* compression */
        ihdr[11] = 0; /* filter */
        ihdr[12] = 0; /* interlace */

        if (png_write_chunk(f, PNG_CN_IHDR, ihdr, sizeof(ihdr), fc) != 0) {
                throw error_png();
        }

        if (mng->pal_size) {
                if (png_write_chunk(f, PNG_CN_PLTE, mng->pal_ptr, mng->pal_size, fc) != 0) {
                        throw error_png();
                }
        }

        png_compress(mng->level, z_ptr, z_size, mng->scroll_ptr, mng->line, mng->pixel, 0, 0, mng->width + mng->scroll_width, mng->height + mng->scroll_height);

        if (png_write_chunk(f, PNG_CN_IDAT, z_ptr, z_size, fc) != 0) {
                throw error_png();
        }

        if (png_write_chunk(f, PNG_CN_IEND, 0, 0, fc) != 0) {
                throw error_png();
        }
}

static void mng_write_move(adv_mng_write* mng, adv_fz* f, unsigned* fc, int shift_x, int shift_y)
{
        unsigned char move[13];

        if (shift_x!=0 || shift_y!=0) {

                be_uint16_write(move + 0, 1); /* id 1 */
                be_uint16_write(move + 2, 1); /* id 1 */
                move[4] = 1; /* adding */
                be_uint32_write(move + 5, - shift_x);
                be_uint32_write(move + 9, - shift_y);

                if (png_write_chunk(f, MNG_CN_MOVE, move, sizeof(move), fc)!=0) {
                        throw error_png();
                }
        }
}

static void mng_write_delta_image(adv_mng_write* mng, adv_fz* f, unsigned* fc, unsigned char* img_ptr, unsigned img_scanline, unsigned char* pal_ptr, unsigned pal_size)
{
        unsigned x,y,dx,dy;
        data_ptr pal_d_ptr;
        unsigned pal_d_size;
        data_ptr pal_r_ptr;
        unsigned pal_r_size;
        data_ptr z_d_ptr;
        unsigned z_d_size;
        data_ptr z_r_ptr;
        unsigned z_r_size;
        unsigned char dhdr[20];
        unsigned dhdr_size;

        if (pal_ptr && pal_size) {
                png_compress_palette_delta(pal_d_ptr, pal_d_size, pal_ptr, pal_size, mng->pal_ptr);

                pal_r_ptr = data_dup(pal_ptr, pal_size);
                pal_r_size = pal_size;
        } else {
                pal_d_ptr = 0;
                pal_d_size = 0;
                pal_r_ptr = 0;
                pal_r_size = 0;
        }

        compute_image_range(mng, &x, &y, &dx, &dy, img_ptr, img_scanline);

        if (dx && dy) {
                png_compress_delta(mng->level, z_d_ptr, z_d_size, img_ptr, img_scanline, mng->pixel, mng->current_ptr, mng->line, x, y, dx, dy);
                png_compress(mng->level, z_r_ptr, z_r_size, img_ptr, img_scanline, mng->pixel, x, y, dx, dy);
        } else {
                z_d_ptr = 0;
                z_d_size = 0;
                z_r_ptr = 0;
                z_r_size = 0;
        }

        be_uint16_write(dhdr + 0