source: svn/trunk/newcon3bcm2_21bu/dta/tools/pngtoraw.c @ 5

/***************************************************************
**
** Broadcom Corp. Confidential
** Copyright 2002 Broadcom Corp. All Rights Reserved.
**
** THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED 
** SOFTWARE LICENSE AGREEMENT BETWEEN THE USER AND BROADCOM. 
** YOU HAVE NO RIGHT TO USE OR EXPLOIT THIS MATERIAL EXCEPT 
** SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
**
** Description: convert simple clut 8 pngs to raw clut images
**
** Created: 8/22/2002 by Jeffrey P. Fisher
**
**
**
****************************************************************/

#include <sys/time.h> /* for gettimeofday() */
#include <stdio.h>    /* for fprintf()      */
#include <stdlib.h>   /* for rand()         */
#include <unistd.h>   /* for sleep()        */
#include <string.h>   /* for memset()       */
#include <stdio.h>
#include <png.h>

/* Broadcom includes */

/* structure holding all necessary decode info */
typedef struct ptw_t
{
        FILE *log_fp;
        png_structp png_ptr;
        png_infop info_ptr;
        png_infop end_info;
        png_uint_32 width;
        png_uint_32 height;
        int bit_depth;
        int color_type; 
        int interlace_method;
        int compression_method;
        int filter_method;
        png_byte channels;
        png_uint_32 rowbytes;
        png_colorp palette;
        int num_palette;
        png_bytep trans;
        int num_trans;
        png_color_16p trans_values;
        png_bytepp row_pointers;
}ptw_t;

typedef struct bcm_raw_8_t
{
        unsigned long version;                  /* version number of raw file - for future use */
        unsigned long type;                             /* type of raw file - for future use */
        unsigned long pitch;                    /* number of bytes per row */
        unsigned short width;                   /* number of pixel per row */
        unsigned short height;                  /* number of rows */
        unsigned char color_key;                /* color key/transparency color value */
        unsigned short clut_size;               /* number of entries in the ARGB8888 CLUT */
}bcm_raw_8_t;

#define DBG_FPRINTF(x)   fprintf x
#define RAW_TYPE                0x52415720
#define RAW_VERSION             0x00000001
/****************************************************************
* validate_png_header
*
* INPUTS:       ptw_p
* OUTPUTS:      none
* RETURNS:      non-zero if supported 
* FUNCTION: Function to inspect header and validate it is a compatible
*                       image
*
****************************************************************/
int validate_png_header(ptw_t *ptw_p)
{
        int supported = 0;
        int format_changed = 0;
        png_get_IHDR(ptw_p->png_ptr, ptw_p->info_ptr, &ptw_p->width, &ptw_p->height,
                                 &ptw_p->bit_depth, &ptw_p->color_type, &ptw_p->interlace_method,
                                 &ptw_p->compression_method, &ptw_p->filter_method);
        ptw_p->channels = png_get_channels(ptw_p->png_ptr, ptw_p->info_ptr);
        ptw_p->rowbytes = png_get_rowbytes(ptw_p->png_ptr, ptw_p->info_ptr);

        DBG_FPRINTF((ptw_p->log_fp,"width = %d\n",ptw_p->width));
        DBG_FPRINTF((ptw_p->log_fp,"height = %d\n",ptw_p->height));
        DBG_FPRINTF((ptw_p->log_fp,"bit_depth = %d\n",ptw_p->bit_depth));
        DBG_FPRINTF((ptw_p->log_fp,"color_type = 0x%08x(0x%08x,0x%08x,0x%08x)\n",ptw_p->color_type,
                        ptw_p->color_type & PNG_COLOR_MASK_PALETTE,
                        ptw_p->color_type & PNG_COLOR_MASK_COLOR,
                        ptw_p->color_type & PNG_COLOR_MASK_ALPHA));
        DBG_FPRINTF((ptw_p->log_fp,"channels = %d\n",ptw_p->channels));
        DBG_FPRINTF((ptw_p->log_fp,"rowbytes = %d\n",ptw_p->rowbytes));
        DBG_FPRINTF((ptw_p->log_fp,"interlace_type = %d\n",ptw_p->interlace_method));
        DBG_FPRINTF((ptw_p->log_fp,"compression_type = %d\n",ptw_p->compression_method));
        DBG_FPRINTF((ptw_p->log_fp,"filter_method = %d\n",ptw_p->filter_method));

        supported = (((ptw_p->bit_depth == 8) || (ptw_p->bit_depth == 4)) && (ptw_p->color_type & PNG_COLOR_MASK_PALETTE)
                                 && ((ptw_p->channels == 3) || (ptw_p->channels == 4) || (ptw_p->channels == 1)));
        if (ptw_p->bit_depth == 4)
        {
#if 0
                png_color_8p sig_bit;

                if (png_get_sBIT(ptw_p->png_ptr, ptw_p->info_ptr, &sig_bit))
                        png_set_shift(ptw_p->png_ptr, sig_bit);
#endif
        }

        if (!supported)
        {
                /* Check for ARGB 8888 */

                supported = ((ptw_p->bit_depth == 8) && (ptw_p->color_type & PNG_COLOR_MASK_COLOR));
                if (!(ptw_p->color_type & PNG_COLOR_MASK_ALPHA) || (ptw_p->channels != 4))
                {
                        png_set_add_alpha(ptw_p->png_ptr,0xff,PNG_FILLER_AFTER);
                        format_changed = 1;
                }
#if 0
                if (ptw_p->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
                        png_set_swap_alpha(ptw_p->png_ptr);
#endif
                if (ptw_p->color_type == PNG_COLOR_TYPE_RGB || ptw_p->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
                {
                        png_set_bgr(ptw_p->png_ptr);
                        format_changed = 1;
                }

                if (format_changed)
                {
                        png_read_update_info(ptw_p->png_ptr, ptw_p->info_ptr);
                        png_get_IHDR(ptw_p->png_ptr, ptw_p->info_ptr, &ptw_p->width, &ptw_p->height,
                                                 &ptw_p->bit_depth, &ptw_p->color_type, &ptw_p->interlace_method,
                                                 &ptw_p->compression_method, &ptw_p->filter_method);
                        ptw_p->channels = png_get_channels(ptw_p->png_ptr, ptw_p->info_ptr);
                        ptw_p->rowbytes = png_get_rowbytes(ptw_p->png_ptr, ptw_p->info_ptr);
                }
        }
        DBG_FPRINTF((ptw_p->log_fp,"PNG type %s\n" ,supported ? "Supported":"Not Supported"));
        return supported;
}
/****************************************************************
* read_row_callback
*
* INPUTS:       
* OUTPUTS:      none
* RETURNS:      none 
* FUNCTION:
*
****************************************************************/
void read_row_callback(png_structp ptr, png_uint_32 row, int pass)
{
#ifdef PTR_DEBUG
        printf("read_row_callback(%d,%d)\n",row,pass);
#endif
}
/****************************************************************
* read_chunk_callback
*
* INPUTS:       
* OUTPUTS:      none
* RETURNS:      none 
* FUNCTION:
*
****************************************************************/
int read_chunk_callback(png_structp ptr, png_unknown_chunkp chunk)
{

        /* put your code here.  Return one of the
           following: */
#ifdef PTR_DEBUG
        printf("read_chunk_callback(0x%02%02%02%02%02,%d,%p)\n",
                   chunk->name[0],chunk->name[1],chunk->name[2],
                   chunk->name[3],chunk->name[4],chunk->size,chunk->data);
#endif
        //return(-n);   /* chunk had an error */
        //return(0); /* did not recognize */
        return (chunk->size); /* success */
}


/****************************************************************
* inspect_palette
*
* INPUTS:       ptw_p
* OUTPUTS:      none
* RETURNS:      none 
* FUNCTION: Output the palette and transparency info
*
****************************************************************/
void inspect_palette(ptw_t *ptw_p)
{
        int i,cnt;
        png_get_PLTE(ptw_p->png_ptr, ptw_p->info_ptr, &ptw_p->palette, &ptw_p->num_palette);
        png_get_tRNS(ptw_p->png_ptr, ptw_p->info_ptr, &ptw_p->trans, &ptw_p->num_trans,
                                 &ptw_p->trans_values);

        DBG_FPRINTF((ptw_p->log_fp,"\nRGB Palette[%d]:\n",ptw_p->num_palette));
        for (i = 0; i < ptw_p->num_palette; ++i)
        {
                DBG_FPRINTF((ptw_p->log_fp,"RGB[0x%02x]=0x%02x 0x%02x 0x%02x\n",i,ptw_p->palette[i].red,
                                ptw_p->palette[i].green, ptw_p->palette[i].blue));
        }

        DBG_FPRINTF((ptw_p->log_fp,"\nTransparency[%d]:\n",ptw_p->num_trans));
        for (i = 0; i < ptw_p->num_trans; ++i)
        {
                DBG_FPRINTF((ptw_p->log_fp,"TRN[0x%02x]=0x%02x\n",i,ptw_p->trans[i]));
        }

        cnt = 0;
        DBG_FPRINTF((ptw_p->log_fp,"\nARGB Palette[%d]:\n",ptw_p->num_palette));
        for (i = 0; i < ptw_p->num_palette; ++i)
        {
                DBG_FPRINTF((ptw_p->log_fp,"0x%02x%02x%02x%02x,",(i < ptw_p->num_trans) ? ptw_p->trans[i] : 0xFF ,
                        ptw_p->palette[i].red, ptw_p->palette[i].green, ptw_p->palette[i].blue));
                if (cnt++ >= 0x7)
                {
                        cnt = 0;
                        DBG_FPRINTF((ptw_p->log_fp,"\n"));
                }
        }
        DBG_FPRINTF((ptw_p->log_fp,"\n"));
}
/****************************************************************
* get_color_key
*
* INPUTS:       ptw_p
* OUTPUTS:      none
* RETURNS:      value or -1 if no value is found 
* FUNCTION: Get the first transparent value
*
****************************************************************/
unsigned char get_color_key(ptw_t *ptw_p)
{
        int i;
        //printf("get_color_key %d\n", ptw_p->num_palette);
        for (i = 0; i < ptw_p->num_trans; ++i)
        {
                if (ptw_p->trans[i] == 0)
                {
                        if (i >= ptw_p->num_palette)
                                return (ptw_p->num_palette - 1);
                        return i;
                }
        }
        return ptw_p->num_palette - 1;
}

/****************************************************************
* Output a row (bit_depth = 4 only)
*
****************************************************************/
void print_row(unsigned char* p_row,int width, int pitch, int rowbytes)
{
#if 0
        int i;
        for (i = 0; i < width; ++i)
        {
                if (i & 1)
                {
                        printf("0x%1x,", p_row[i / 2] & 0x0F);
                }
                else
                {
                        printf("0x%1x,", (p_row[i / 2] >> 4) & 0x0F);
                }
        }
        printf("\n");
        for (i = 0; i < width; ++i)
        {
                printf("0x%02x,", p_row[i]);
        }
        printf("\n");
#endif
}
/****************************************************************
*
****************************************************************/
void hex_output(FILE* f,unsigned char* ptr,int len)
{
        int i;
        for (i = 0; i < len; i++)
        {
                if (i % 8 == 0)
                {
                        fprintf(f,"\n\t");
                }
                fprintf(f,"0x%02x, ",ptr[i]);
        }
}
/****************************************************************
* main
*
* INPUTS:               arc - argument count
*                           argv - array of arguments
* OUTPUTS:              none
* RETURNS:              none
* FUNCTION:             main entry point
* DESCRIPTION:  Convert PNGs to raw clut 8 images.
*
****************************************************************/

int main(int argc, char *argv[])
{
        FILE *fp = NULL;
        FILE *out_fp = NULL;
        int result = -1; 
        char header[8];
        int is_png,row,i,palette_only,yuv,cfile;
        ptw_t ptw;
        bcm_raw_8_t raw;
        unsigned long clut[0xFF];
        FILE* logfile = NULL;
        palette_only = 0;
        cfile = 0;

        memset(clut,0,sizeof(unsigned long) * 0xFF);
        memset(&ptw,0,sizeof(ptw_t));
        yuv = 1;

        if (argc < 3)
        {
                printf("USAGE: pngtoraw <png filename> <out_filename> [-p -v -r -c]\n");
                printf("\t-p  Output a raw palette only\n");
                printf("\t-r  Output RGB palette (default is YUV)\n");
                printf("\t-v  Verbose mode\n");
                printf("\t-c  Output raw image as C structure\n");
                goto done;
        }

        for (i = 3; i < argc; ++i)
        {
                if ((strcmp(argv[i],"-v") == 0) || (strcmp(argv[i],"-V") == 0))
                {
                        ptw.log_fp = stdout;
                }
                else if ((strcmp(argv[i],"-p") == 0) || (strcmp(argv[i],"-P") == 0))
                {
                        printf("Output palette only\n");
                        palette_only = 1;
                }
                else if ((strcmp(argv[i],"-r") == 0) || (strcmp(argv[i],"-R") == 0))
                {
                        printf("Output RGB palette\n");
                        yuv = 0;
                }
                else if ((strcmp(argv[i],"-c") == 0) || (strcmp(argv[i],"-C") == 0))
                {
                        printf("Output raw image as C structure.\n");
                        cfile = 1;
                }
        }
        if (!ptw.log_fp)
        {
                logfile = ptw.log_fp = fopen("pngtoraw.log", "w");
        }
        
        fp = fopen(argv[1], "rb");
        if (!fp)
        {
                printf("Error opening file %s\n",argv[1]);
                goto done;
        }

        out_fp = fopen(argv[2], "wb");
        if (!out_fp)
        {
                printf("Error opening file %s\n",argv[2]);
                goto done;
        }

        /* check the PNG header */
        fread(header, 1, 8, fp);
        is_png = !png_sig_cmp(header, 0, 8);
        if (!is_png)
        {
                printf("%s not a PNG file\n",argv[1]);
                goto done;
        }

        /* Initialize the PNG library and structures */
        ptw.png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
                                                                                  NULL, NULL);
        if (!ptw.png_ptr)
        {
                printf("png_create_read_struct error\n");
                goto done;
        }

        ptw.info_ptr = png_create_info_struct(ptw.png_ptr);
        if (!ptw.info_ptr)
        {
                printf("png_create_info_struct error\n");
                goto done;
        }

        ptw.end_info = png_create_info_struct(ptw.png_ptr);
        if (!ptw.end_info)
        {
                printf("png_create_info_struct error\n");
                goto done;
        }
        
        png_init_io(ptw.png_ptr, fp);

    png_set_sig_bytes(ptw.png_ptr,8);

        png_set_read_user_chunk_fn(ptw.png_ptr, &ptw, read_chunk_callback);
        png_set_read_status_fn(ptw.png_ptr, read_row_callback);

        png_read_info(ptw.png_ptr, ptw.info_ptr);

        if (!validate_png_header(&ptw))
                goto done;

        if (ptw.color_type & PNG_COLOR_MASK_PALETTE)
        {
                inspect_palette(&ptw);
        }

        // png_read_png(ptw.png_ptr, ptw.info_ptr,PNG_TRANSFORM_IDENTITY , NULL);
        ptw.row_pointers = png_malloc(ptw.png_ptr, ptw.height * sizeof(ptw.row_pointers));
        for (row = 0; row < ptw.height; row++)
        {
           ptw.row_pointers[row] = png_malloc(ptw.png_ptr, ptw.rowbytes);
        }
        png_read_image(ptw.png_ptr, ptw.row_pointers);
                
        png_read_end(ptw.png_ptr, ptw.end_info);
        
        /* pitch required for broadcom surface */
        //raw.pitch =  ((((ptw.width * 4) / 4/* pp4 bytes */) +  0xF) &  ~0xF);
        if (ptw.color_type & PNG_COLOR_MASK_PALETTE)
                raw.pitch =  (ptw.width * ptw.bit_depth) / 8;
        else
                raw.pitch =  ptw.rowbytes;

        raw.width = ptw.width;
        raw.height = ptw.height;
        raw.clut_size = ptw.num_palette;
        raw.type = RAW_TYPE;
        raw.version = RAW_VERSION;
        DBG_FPRINTF((ptw.log_fp,"raw.pitch = %d\n",raw.pitch));
        DBG_FPRINTF((ptw.log_fp,"raw.width = %d\n",raw.width));
        DBG_FPRINTF((ptw.log_fp,"raw.height = %d\n",raw.height));
        DBG_FPRINTF((ptw.log_fp,"raw.clut_size = %d\n",raw.clut_size));

        if (!cfile)
        {
                fwrite((char*)&raw,1,sizeof(raw),out_fp); 
        }
        else
        {
                char *dot_ptr;
                unsigned char *ptr;
                static char out_name[1024];
                int len;

                fprintf(out_fp,"/* FILE: %s */\n",argv[2]);
                fprintf(out_fp,"/* pitch: %d */\n",raw.pitch);
                fprintf(out_fp,"/* width: %d */\n",raw.width);
                fprintf(out_fp,"/* height: %d */\n",raw.height);
                fprintf(out_fp,"/* clut_size: %d */\n",raw.clut_size);

                dot_ptr = strstr(argv[2],".");

                if (!dot_ptr)
                {
                        sprintf(out_name,"%s.c",argv[2]);
                }
                else
                {
                        strcpy(out_name,argv[2]);
                        dot_ptr[0] = 0;
                        sprintf(out_name,"%s.c",argv[2]);
                }

                len = sizeof(raw) + (raw.pitch * raw.height) + (raw.clut_size * sizeof(unsigned int));
                fprintf(out_fp,"\nunsigned int g_%s_size = %d;\n",argv[2],len);
                fprintf(out_fp,"const unsigned char g_%s[] = \n{\n\t",argv[2]);
                hex_output(out_fp,(unsigned char*)&raw,sizeof(raw));
        }

        if (ptw.color_type & PNG_COLOR_MASK_PALETTE)
        {
                raw.color_key = get_color_key(&ptw);
                DBG_FPRINTF((ptw.log_fp,"raw.color_key = 0x%02x\n",raw.color_key));
                for (i = 0; i < raw.clut_size; ++i)
                {
                        unsigned long trans;
                        if (i < ptw.num_trans)
                                trans = ptw.trans[i];
                        else
                                trans = 0xFF;
                        
                        if ((ptw.num_trans == 0) && (i == raw.color_key))
                        {
                                trans = 0;
                        }
        
                        if (yuv)
                        {
                                unsigned int Y,U,V;
                                unsigned int R,G,B;
                                R = ((unsigned int)ptw.palette[i].red) & 0xFF;
                                G = ((unsigned int)ptw.palette[i].green) & 0xFF;
                                B = ((unsigned int)ptw.palette[i].blue) & 0xFF;
        
                                Y  =      (0.257 * R) + (0.504 * G) + (0.098 * B) + 16;
        
                                V =  (0.439 * R) - (0.368 * G) - (0.071 * B) + 128;
        
                                U = -(0.148 * R) - (0.291 * G) + (0.439 * B) + 128;
        
                                clut[i] = (trans << 24) | 
                                                ((Y & 0xFF) << 16) |
                                                ((U & 0xFF) << 8) | 
                                                (V & 0xFF);
                        }
                        else
                        {
                                clut[i] = (trans << 24) | 
                                                (((unsigned long)ptw.palette[i].red) << 16) |
                                                (((unsigned long)ptw.palette[i].green) << 8) | 
                                                (unsigned long)ptw.palette[i].blue;
                        }
                }

                /* ouput the file */
                if (cfile)
                {
                        hex_output(out_fp,(unsigned char*)clut,(sizeof(unsigned long) * raw.clut_size));
                }
                else
                {
                        fwrite((char*)&clut,1,(sizeof(unsigned long) * raw.clut_size),out_fp); 
                }
        }
        
        if (palette_only)
                goto done;

        for (row = 0; row < raw.height; row++)
        {
                if (cfile)
                        hex_output(out_fp,(unsigned char*)ptw.row_pointers[row],raw.pitch);
                else
                        fwrite((char*)ptw.row_pointers[row],1,raw.pitch,out_fp);
                
                print_row((char*)ptw.row_pointers[row],raw.width, raw.pitch,ptw.rowbytes);

                if (ptw.rowbytes < raw.pitch)
                {
                        if (cfile)
                                hex_output(out_fp,(unsigned char*)ptw.row_pointers[row],raw.pitch - ptw.rowbytes);
                        else
                                fwrite((char*)ptw.row_pointers[row],1,raw.pitch - ptw.rowbytes,out_fp); 
                }
        }
        if (cfile)
                fprintf(out_fp,"\n};\n");

done:

        if (ptw.png_ptr && !ptw.info_ptr && !ptw.end_info)
                png_destroy_read_struct(&ptw.png_ptr, (png_infopp)NULL, (png_infopp)NULL);
        if (ptw.png_ptr && ptw.info_ptr && !ptw.end_info)
                png_destroy_read_struct(&ptw.png_ptr, (png_infopp)&ptw.info_ptr, (png_infopp)NULL);
        if (ptw.png_ptr && ptw.info_ptr && ptw.end_info)
                png_destroy_read_struct(&ptw.png_ptr, (png_infopp)&ptw.info_ptr, (png_infopp)&ptw.end_info);
        if (fp)
                fclose(fp);
        if (out_fp)
                fclose(out_fp);
        if (logfile)
                fclose(logfile);

        return result;
}