X-Git-Url: https://www.kengrimes.com/gitweb/?p=henge%2Fapc.git;a=blobdiff_plain;f=src%2Fbinaryout.c;h=8627be685b83a8d081b56a8b9539da1495eac914;hp=ee82c6f99ad56a3c1e2b90db0ee8e5458f9a56ba;hb=32253ca6184bceb23486c7d92ea209b7cb4b7b58;hpb=db01318a8e246249ceea23255a6512ea8a5c00c2 diff --git a/src/binaryout.c b/src/binaryout.c index ee82c6f..8627be6 100644 --- a/src/binaryout.c +++ b/src/binaryout.c @@ -10,16 +10,17 @@ #include //u32_cpy #include //ulc_fprintf /* Local */ +#define eprintf_callback(...) exit(EXIT_FAILURE) #include "print.h" #include "apc.h" #include "ir.h" #include "pagenode.h" -#undef do_error -#define do_error(...) exit(-1) #define XXH_PRIVATE_API #include "../xxHash/xxhash.h" #define STB_IMAGE_IMPLEMENTATION -#include "stb_image.h" +#include "../stb/stb_image.h" +#define STB_IMAGE_WRITE_IMPLEMENTATION +#include "../stb/stb_image_write.h" /* Public */ void ir_binout_init(struct ir_class_t*); @@ -27,7 +28,7 @@ void ir_binout_init(struct ir_class_t*); /* Memory Allocation */ #define struct_alloc(_T) ((struct _T*) stack_alloc(&datapages, sizeof(struct _T))) static -struct pagelist_t linkpages, datapages; +struct pagelist_t linkpages, datapages, plinkpages; enum model_type { SS }; /* Binaryout out structure definitions */ @@ -71,31 +72,22 @@ struct bin_frame_header_t { int frames; long op_start; }; -struct bin_plink_t { - enum ltype type; - ir_set trg_set; - uint8_t* name; - long src_pos; -}; + struct bin_pixel_t { int x, y, z; uint32_t ref; + int attach_idx; }; struct bin_pixel_node_t { struct bin_pixel_node_t* next; struct bin_pixel_t data; }; -struct bin_op_t { - int x; - int y; - int attach_idx; -}; struct bin_attachment_header_t { int num_attachment_lists; int num_attachments; }; struct bin_attachment_t { - int idx; + int x, y, z, idx; ir_set set; }; /* Read out of the als, after first ir pass, resolves the @@ -111,9 +103,41 @@ struct bin_attachment_list_t **attachment_stack, **asp; //attachment_stack, atta FILE* binaryout; - #define NAMEHASH(name, domain) (XXH32(name, u8_strlen(name), 0XCEED ) & domain) +static inline +int bin_set_varcount +( ir_set set ) +{ int count; + framebox iter; + count = 0; + for (iter = ir_set_framebox(set); iter != NULL; iter = ir_setdata_nextsib(iter)) + count++; + return count; +} + +static inline +int bin_class_sibcount +( ir_class class ) +{ int count; + ir_class iter; + count = 0; + for (iter = class; iter != NULL; iter = ir_class_nextsib(iter)) + count++; + return count; +} + +static inline +int bin_set_sibcount +( ir_set set ) +{ int count; + ir_set iter; + count = 0; + for (iter = set; iter != NULL; iter = ir_set_nextsib(iter)) + count++; + return count; +} + /* Given a position and a size, checks if the bytes are null and returns the file position to where it started. 1 if not null, 0 if null*/ /* TODO: Determine why fseeking file past end sets bytes to -1, and not 0 */ @@ -143,6 +167,9 @@ int bin_keys_identical return 0; } + +typedef RGBA_t uint32_t; + long bin_traverse_class(ir_class); /* Takes root class and begins processing */ void @@ -165,7 +192,7 @@ ir_binout_init(ir_class root_class) if(fseek(binaryout, entry_pos, SEEK_SET) == -1) eprintf("fseek failed with %s", strerror(errno)); \ } while (0) #define HT_END(_HTEND) (entry_pos >= _HTEND) //just in case at last entry -void +long /* TODO: Should overwrite be a default? */ bin_insert_ht_entry ( long ht_start, @@ -197,6 +224,8 @@ bin_insert_ht_entry INC_ENTRY(); } WRITE_ENTRY(); + + return entry_pos; } @@ -230,10 +259,10 @@ bin_traverse_class uint8_t* class_name; class_start = ftell(binaryout); - class_name = get_class_name(class); + class_name = ir_class_name(class); - num_csibs = get_class_sibcount(class); - num_ssibs = get_set_sibcount(get_class_root_set(class)); + num_csibs = bin_class_sibcount(class); + num_ssibs = bin_set_sibcount(ir_class_rootset(class)); /* alloc space (before hash tables) for class header */ class_header.namelen = u8_strlen(class_name); @@ -253,19 +282,23 @@ bin_traverse_class fwrite(class_name, class_header.namelen, 1, binaryout); /* Start populating root_set hash table */ - for ( siter = get_class_root_set(class); siter != NULL; siter = get_set_nextsib(siter)) + for ( siter = ir_class_rootset(class); siter != NULL; siter = ir_set_nextsib(siter)) { fseek(binaryout, 0, SEEK_END); - ht_entry.key = NAMEHASH(get_set_name(siter), num_ssibs << 1); + ht_entry.key = NAMEHASH(ir_set_name(siter), num_ssibs << 1); ht_entry.value = bin_traverse_set(siter); bin_insert_ht_entry(rootsetht_start, rootsetht_size, &ht_entry, 0); } /* Start populating class child hash table */ - for ( citer = get_class_nextchild(class); citer != NULL; citer = get_class_nextsib(citer)) - { fseek(binaryout, 0, SEEK_END); - ht_entry.key = NAMEHASH(get_class_name(citer), num_csibs << 1); + for ( citer = ir_class_nextchild(class); citer != NULL; citer = ir_class_nextsib(citer)) + { if(chdir((char*) class_name)) + eprintf("CHDIR %U from %s\n",(char*) class_name,getcwd(NULL,255)); + fseek(binaryout, 0, SEEK_END); + ht_entry.key = NAMEHASH(ir_class_name(citer), num_csibs << 1); ht_entry.value = bin_traverse_class(citer); bin_insert_ht_entry(classht_start, classht_size, &ht_entry, 0); + if (chdir("..")) + eprintf("CHDIR ..\n"); } return class_start; @@ -294,7 +327,7 @@ bin_traverse_set uint8_t* set_name; set_start = ftell(binaryout); - set_name = get_set_name(set); + set_name = ir_set_name(set); /* alloc space for set header */ setname_len = u8_strlen(set_name); @@ -304,7 +337,7 @@ bin_traverse_set header.sdat_start = bin_process_sdat(set); /* Setup child hash table for current sets children */ - num_child = get_set_sibcount(get_set_nextchild(set)); + num_child = bin_set_sibcount(ir_set_nextchild(set)); HT_INIT(childht_start, childht_size, num_child); /* populate header, write to file */ @@ -314,19 +347,25 @@ bin_traverse_set fwrite(&header, sizeof(struct bin_set_header_t), 1, binaryout); fwrite(set_name, setname_len, 1, binaryout); - for(iter = get_set_nextchild(set); iter != NULL; iter = get_set_nextsib(iter)) + for(iter = ir_set_nextchild(set); iter != NULL; iter = ir_set_nextsib(iter)) { fseek(binaryout, 0, SEEK_END); - ht_entry.key = NAMEHASH(get_set_name(iter), num_child << 1); + ht_entry.key = NAMEHASH(ir_set_name(iter), num_child << 1); ht_entry.value = bin_traverse_set(iter); bin_insert_ht_entry(childht_start, childht_size, &ht_entry, 0); } - set_set_filepos(set, set_start); + ir_set_assign_fpos(set, set_start); return set_start; } /* | sdat header | + |------------------| + | num dlinks | + |------------------| + | dlink len | + |------------------| + | dlink string | |------------------| | variant ht | |------------------| @@ -338,10 +377,11 @@ bin_traverse_set */ -void bin_insert_links(int, struct bin_ht_header_t*, long); +void bin_insert_links(struct bin_processed_lists_t*, struct bin_ht_header_t*, long); struct bin_pixel_node_t* bin_find_default_pixel_list(ir_set); void bin_process_frameboxes(ir_set, struct bin_ht_header_t*, struct bin_pixel_node_t*); int bin_process_links(ir_set, ir_setdata); +int bin_process_dlinks(struct bin_processed_lists_t*); /* Init the variant hash table for the set, process the sets links and add them to link_stack and variant hash table, and then output the actual framedata */ @@ -352,17 +392,23 @@ bin_process_sdat struct bin_attachment_list_t attachment_list; struct bin_pixel_node_t *default_pixel_list; struct bin_ht_header_t ht_header; + struct bin_processed_links_t* processed_links_root; long varht_start, varht_size, sdat_start; int num_entries, num_links; - ir_setdata olink_head; sdat_start = ftell(binaryout); /* Alloc position for sdat_header */ fseek(binaryout, sizeof(struct bin_setdata_header_t), SEEK_CUR); - num_links = bin_process_links(set, olink_head); - num_entries = get_set_variants(set) + num_links; + /* set up root for processed_links */ + processed_links_root = stack_alloc(&plinkpages, bin_processed_links_t); + processed_links_root_val->mlink_len = processed_links_root->vlink_len = 0; + processed_links_root = bin_process_links(set, processed_links_root); + + num_links = processed_links_root->mlink_len + processed_links_root->vlink_len; + + num_entries = bin_set_varcount(set) + num_links; HT_INIT(varht_start, varht_size, num_entries); @@ -374,78 +420,111 @@ bin_process_sdat fwrite(&header, sizeof(header), 1, binaryout); fseek(binaryout, 0, SEEK_END); - /* insert the links that were processed into the variant hash table */ - bin_insert_links(num_links, &ht_header, attachment_list.filepos); + /* Process dlinks */ + bin_process_dlinks(processed_links_root); + + /* Determine the default pixel list for all of the frameboxes */ default_pixel_list = bin_find_default_pixel_list(set); /* Output each framebox, and insert it into the variant hash table */ bin_process_frameboxes(set, &ht_header, default_pixel_list); + /* insert the links that were processed into the variant hash table */ + bin_insert_links(processed_links_root, &ht_header, attachment_list.filepos); + /* TODO: Convert the default pixel list to an attachment_list and then push the */ /* sdats attachment_list onto the attachment_stack so it can be procesed */ + /* free plinkpages and datapages */ + return sdat_start; } +static inline +void bin_process_dlinks +( struct bin_processed_links_t* processed_links ) +{ struct bin_linklist_t* olink_iter; + ir_set trg_set; + for( dlink_iter = processed_links->dlink_list; dlink_iter != NULL; dlink_iter = dlink_iter->next) + { /* Construct its fully qualified name based on ?*/ + /* Output an int for its length, and then output the name */ + + + } +} +static inline +struct bin_linklist_t* bin_linklist_head +( struct bin_linklist_t* root ) +{ struct bin_linklist_t* head; + head = root; + while(head->next) + head = head->next; + return head; +} -/* Adds a vlink onto the stack_alloc to be popped during the processing of the - sets variant hash table. If the vlink has a name, its a vlink to a single - variant. if the vlink doesnt have a name, its the vlink to an entire variant - hash table, and each variant (framebox) needs to be added */ -int +/* We dont know src_pos at this point because this is still in the control flow + of bin_process_links, which determines the number of links, which determines + the hash table. */ +void +#define PUSH_LINK(_LINK) (*(linkdata*) stack_alloc(&linkpages, sizeof(linkdata)) = _LINK) bin_process_vlink -( ir_setdata vlink, - ir_set trg_set -) -{ struct bin_plink_t* plp; +( linkdata vlink, + struct bin_processed_links_t* processed_links) +{ struct bin_processed_links_t* plp; + struct bin_linklist_t* vlink_list_head; + linkdata new_vlink; ir_setdata fiter; + ir_set trg_set; uint8_t* link_name; - int num_links; - - num_links = 0; - /* TODO: Macroize? or not worth? */ - link_name = get_link_name(vlink); - - if (link_name) - { plp = struct_alloc(bin_plink_t); - plp->src_pos = 0; // TBD @ process_setdata - plp->name = link_name; - plp->trg_set = trg_set; - plp->type = VLINK; - num_links++; + vlink_list_head = bin_linklist_head(processed_links->vlink_list); + link_name = ir_setdata_name(vlink); + if (link_name) + { plp = struct_alloc(bin_processed_links_t); + plp->linkdata = vlink; + vlink_list_head->next = plp; + processed_links->vlink_len++; + PUSH_LINK(vlink); } else // linking a variant hash table - for (fiter = get_set_frameboxes(trg_set); fiter != NULL; fiter = get_framebox_nextsib(fiter)) - { plp = struct_alloc(bin_plink_t); - plp->src_pos = 0; // TBD @ process_setdata - plp->name = get_framebox_name(fiter); - plp->trg_set = trg_set; - plp->type = VLINK; - num_links++; + { trg_set = ir_linkdata_set(vlink); + for (fiter = ir_set_framebox(trg_set); fiter != NULL; fiter = ir_setdata_nextsib(fiter)) + { plp = struct_alloc(bin_processed_links_t); + new_vlink = struct_alloc(linkdata); + ir_linkdata_assign_name(new_vlink,ir_setdata_name(fiter)); + ir_linkdata_assign_set(new_vlink,trg_set); + ir_linkdata_assign_type(new_vlink,VLINK); + plp->linkdata = vlink; + vlink_list_head->next = plp; + processed_links->vlink_len++; + PUSH_LINK(vlink); } + } - return num_links; + return processed_links; } /* Adds an mlink to the stack_alloc, to be processed later */ -int +void bin_process_mlink -( ir_setdata mlink, - ir_set trg_set +( linkdata mlink, + bin_processed_links_t* processed_links ) -{ struct bin_plink_t* plp; - uint8_t* mlink_name; - mlink_name = get_link_name(mlink); - plp = struct_alloc(bin_plink_t); - plp->src_pos = 0; //TBD after resolving the childlist | TODO: attach_pos? - if(mlink_name) plp->name = mlink_name; - plp->trg_set = trg_set; - plp->type = MLINK; - - return 1; +{ uint8_t* mlink_name; + struct bin_processed_links_t* mlink_list_head; + + mlink_list_head = bin_listlist_head(processed_links->mlink_list); + mlink_name = ir_setdata_name(mlink); + plp = stack_alloc(&linkpages, bin_linklist_t); + plp->header.filepos = 0; //TBD after resolving the childlist | TODO: attach_pos? + if(mlink_name) plp->name = mlink_name;// TODO: What does a mlink with a name mean? specifying the framebox mapsheet to use? + plp->trg_set = ir_linkdata_set(mlink); + mlink_list_head->next = plp; + processed_links->mlink_len++; + + return processed_links; } /* TODO: implement this */ @@ -453,91 +532,121 @@ bin_process_mlink if it is, theres a cycle, return 1. Else return 0. */ static inline int olink_cycle -( ir_setdata olink, - ir_setdata olink_head ) -{ ir_setdata iter; - +( linkdata olink, + struct bin_processed_links_t* processed_links +) +{ struct bin_linklist_t* iter; + ir_set olink_set; + olink_set = ir_linkdata_set(olink); + for( iter = processed_links->olink_list; iter != NULL; iter = iter->next) + if(iter == olink_set) + return 1; - return 0; - - } +/* if olink, process target sets frameboxes(turn into vlinks) and its attachment_list (turn into mlink), + else its a dlink so just add it to the processed_links list*/ +static inline +void bin_process_olink +( linkdata olink, + struct bin_processed_links_t* processed_links_root, + ir_set trg_set +) +{ struct bin_linklist_t* link_list_head; + if(trg_set)) //add olink to list so we can check for cycles + { bin_set_frameboxes_vlinks(trg_set, processed_links_root); //TODO: implement + bin_set_attachmentlist_mlink(trg_set, processed_links_root); //TODO: implement + link_list_head = bin_linklist_head(processed_links_root->olink_list); + link_list_head->next = struct_alloc(bin_linklist_t); + link_list_head->next->linkdata = olink; + } + else // olink is actually a dynamic link + { link_list_head = bin_linklist_head(processed_links_root->dlink_list); + link_list_head->next = struct_alloc(bin_linklist_t); + link_list_head->next->linkdata = olink; + } + +} + +struct bin_linklist_t; +struct bin_linklist_t +{ struct bin_linklist_t* next; + linkdata linkdata; +}; + +struct bin_processed_links_t +{ struct bin_linklist_t* vlink_list; + int vlink_len; + struct bin_linklist_t* mlink_list; + int mlink_len; + struct bin_linklist_t* olink_list; //keep track of olink cycles + int olink_len; + struct bin_linklist_t* dlink_list; + int dlink_len; +}; /* Given a set, determine the number of links it has and process each link and then add them to stack_alloc, where they will be popped off and further processed. */ -int -bin_process_links +struct bin_processed_links_t* bin_process_links ( ir_set src_set, - ir_setdata olink_head + struct bin_processed_links_t* processed_links_root; ) -{ int num_links; - ir_setdata liter; //link iter +{ struct bin_processed_links_t* returned_val; + linkdata linkdata; ir_set trg_set; - - num_links = 0; - - for(liter = get_set_links(src_set); liter != NULL; liter = get_link_nextsib(liter)) - { trg_set = get_set_from_ref(get_link_ref(liter)); - switch (get_link_type(liter)) { + for(linkdata = ir_set_link(src_set); linkdata != NULL; linkdata = (linkdata) ir_setdata_nextsib((ir_setdata) linkdata)) + { switch (ir_linkdata_type(linkdata)) { case OLINK: - if (olink_cycle(liter, olink_head)) //TODO: stack of olinks to iterate and check for cycles? - return num_links; - num_links += bin_process_vlink(liter, trg_set); - num_links += bin_process_mlink(liter, trg_set); - num_links += bin_process_links(trg_set, liter); + if (olink_cycle(linkdata, processed_links_root)) + return processed_links_root; //TODO: what return value? + trg_set = ir_linkdata_set(linkdata); + bin_process_olink(trg_set, linkdata, processed_links_root); + bin_process_links(trg_set, processed_links_root); break; case VLINK: - num_links += bin_process_vlink(liter, trg_set); + bin_process_vlink(linkdata, processed_links_root); break; case MLINK: - num_links += bin_process_mlink(liter, trg_set); + bin_process_mlink(linkdata, processed_links_root); break; case ALINK: //TODO: ? break; } } - return num_links; + return processed_links_root; } /* Insert both mlinks and vlinks into the link stack, after determining their src_pos. Vlinks have an additional requirement of being added into the variant hash table */ -#define pop_linkp() (*(struct bin_plink_t**) pagelist_pop(&datapages, sizeof(struct bin_plink_t*))) -#define PUSH_PLINK(_LINK) (*(struct bin_plink_t**) stack_alloc(&linkpages, sizeof (_LINK)) = _LINK ) +#define PUSH_PLINK(_LINK) (*(struct **) stack_alloc(&linkpages, sizeof (_LINK)) = _LINK ) void bin_insert_links -( int num_links, +( struct bin_processed_links_t* links, struct bin_ht_header_t* ht, long attach_pos ) { struct bin_plink_t* plp; struct bin_ht_entry_t ht_entry; - int i; + struct link_list_t* vlinkiter, mlinkiter; + long entry_pos; + /* Insert vlinks into hash table, put v/mlinks on link stack to be processed later */ - for ( i = 0; i < num_links; i++) - { plp = pop_linkp(); - switch (plp->type) { - case MLINK: - plp->trg_set = plp->trg_set; - plp->src_pos = attach_pos; - PUSH_PLINK(plp); - break; - case VLINK: - ht_entry.key = NAMEHASH(plp->name, ht->entries << 1); - ht_entry.value = 0; - bin_insert_ht_entry(ht->start, ht->entries * sizeof(ht_entry), &ht_entry, 0); - plp->src_pos = ht_entry.key + sizeof(ht_entry.key); - PUSH_PLINK(plp); - break; - case OLINK: - break; - //shouldnt exist - case ALINK: - break; - //TBD - } + for ( vlinkiter = links->vlink_root; vlinkiter != NULL; vlinkiter = vlinkiter->next;) + { ht_entry.key = NAMEHASH(ir_setdata_name(vlinkiter->linkdata), ht->entries << 1); + ht_entry.value = 0; + entry_pos = bin_insert_ht_entry(ht->start, ht->entries * sizeof(ht_entry), &ht_entry, 0); + ir_setdata_assign_fpos(vlinkiter->linkdata, entry_pos); + PUSH_PLINK(vlinkiter->linkdata); + } + for ( mlinkiter = links->mlink_root; mlinkiter != NULL; mlinkiter = mlinkiter->next) + { >trg_set = plp->trg_set; + plp->src_pos = attach_pos; + PUSH_PLINK(plp); } + /* Process dlinks here */ + + } long bin_process_facing(ir_setdata, apc_facing, struct bin_pixel_node_t*); @@ -587,9 +696,9 @@ bin_process_frameboxes ir_setdata fiter; /* Insert variants into hash table to overwrite olink insertions*/ - for ( fiter = get_set_frameboxes(set); fiter != NULL; fiter = get_framebox_nextsib(fiter)) + for ( fiter = ir_set_framebox(set); fiter != NULL; fiter = ir_setdata_nextsib(fiter)) { fseek(binaryout, 0, SEEK_END); - ht_entry.key = NAMEHASH(get_framebox_name(fiter), ht->entries << 1); + ht_entry.key = NAMEHASH(ir_setdata_name(fiter), ht->entries << 1); ht_entry.value = bin_process_framebox(set, fiter, default_pixel_list); bin_insert_ht_entry(ht->start, ht->entries * sizeof(ht_entry), &ht_entry, 1); } @@ -599,170 +708,251 @@ bin_process_frameboxes static inline void bin_set_img_info ( struct bin_img_info_t* img_info, - ir_setdata framedata + ir_setdata frame_data ) -{ img_info->fwidth = get_framedata_width(framedata); - img_info->fheight = get_framedata_height(framedata); +{ ir_frameinfo frameinfo; + frameinfo = ir_framedata_frameinfo(frame_data); + img_info->fwidth = frameinfo->w; + img_info->fheight = frameinfo->h; img_info->unaligned_height = img_info->height % img_info->fheight; img_info->unaligned_width = img_info->width % img_info->fwidth; } +/* |-----------------------------| + | frame header | + |-----------------------------| + | pixel data for frame1 - n | + |-----------------------------| + | op data for frame1 - n | + |-----------------------------| */ -/* TODO: Implement this */ -long -bin_process_frame - () -{} - - - -/* Combine the framesheet and mapsheet to create - the output sheet */ -/* |-------------------------| - | outputsheet header | - |-------------------------| - | pixel data for frame1 | - |-------------------------| - | op data for frame1 | - |-------------------------| - | etc. | */ -//TODO: processing direction sounds dumb, but cant call it process_framesheet because -// its actually the mapsheet and the framesheet. rename to output sheet? -/* THIS FUNCTION IS NOT DONE */ long +#define GENERATE_FILENAME(_N) ((char*) u8_strcat(_N, png_suffix)) bin_process_facing ( ir_setdata framebox, apc_facing facing, struct bin_pixel_node_t* default_pixel_list ) { struct bin_img_info_t mapsheet_info, framesheet_info; - int num_mapchannels, num_framechannels; + int num_mapchannels, num_framechannels, x; + struct bin_frame_header_t header; long facing_start; - unsigned char* mapdata, * framedata; + RGBA_t* mapdata, * framedata; + uint8_t* png_suffix = ".png"; + struct bin_pixel_node_t* map_pixel_list; facing_start = ftell(binaryout); /* Set up data pointers to mapsheet and framesheet, as well as their image infos */ - mapdata = stbi_load(get_framedata_name(get_framebox_facing_mapdata(framebox,SFACE)), &mapsheet_info.width, &mapsheet_info.width, &num_framechannels , 0); - framedata = stbi_load(get_framedata_name(get_framebox_facing_framedata(framebox,SFACE)), &framesheet_info.width, &framesheet_info.height, &num_mapchannels, 0); - bin_set_img_info(&framesheet_info, get_framebox_facing_framedata(framebox, SFACE)); - bin_set_img_info(&mapsheet_info, get_framebox_facing_mapdata(framebox, SFACE)); - - /* TODO: output framesheet/direction header */ + mapdata = (RGBA_t*) stbi_load(GENERATE_FILENAME(ir_setdata_name((ir_setdata) ir_framebox_mapsheet(framebox,SFACE))), &mapsheet_info.width, &mapsheet_info.width, &num_framechannels , 0); + framedata = (RGBA_t*) stbi_load(GENERATE_FILENAME(ir_setdata_name((ir_setdata) ir_framebox_framesheet(framebox,SFACE))), &framesheet_info.width, &framesheet_info.height, &num_mapchannels, 0); + bin_set_img_info(&framesheet_info, ir_framebox_framesheet(framebox, SFACE)); + bin_set_img_info(&mapsheet_info, ir_framebox_mapsheet(framebox, SFACE)); + /* Allocate space for header */ + fseek(binaryout, sizeof(header), SEEK_CUR); + - /* For each frame and map i in framesheet + mapsheet */ - /* output frame data */ - /* output op space for frames */ - /* determine ops in map */ - /* check if ops are acceptable */ - /* output ops */ + /* Output framesheet */ + if(!stbi_write_png(binaryout, framesheet_info.width, framesheet_info.height, 4, mapdata, framesheet_info.fwidth)) + eprintf("error writing out framesheet\n"); + + /* Output framesheet header */ + header.width = framesheet_info.fwidth; + header.height = framesheet_info.fheight; + header.frames = framesheet_info.width / framesheet_info.fwidth; //TODO: division is bad + header.op_start = ftell(binaryout); + fseek(binaryout, facing_start, SEEK_SET); + fwrite(&header, sizeof(header), 1, binaryout); + fseek(binaryout, 0, SEEK_END); + + + /* Assuming that fheight = image height */ + /* For each mapframe in mapsheet */ + for ( x = 0; x < header.frames; x++) + { map_pixel_list = bin_map_to_pixel_list(mapsheet_info, 0, x * mapsheet_info.fwidth, data); + if(!bin_process_map_pixel_list(default_pixel_list, map_pixel_list)) + eprintf("error processing map pixel list\n"); + bin_output_pixel_list(map_pixel_list); + data += mapsheet_info.fwidth; + + } + /* Determine pixel_list */ + + /* Output pixel_list */ return facing_start; } +/* TODO: Please rename all the functions jhc*/ +static inline +void bin_number_pixel_list +( struct bin_pixel_node_t* pixel_list ) +{ int num = 0; + struct bin_pixel_node_t* iter; + while (iter) + { iter.data.attach_idx = num++; + iter = iter->next; + } +} + +/* Assuming at this point that map_pixel_list is valid */ +static inline +int bin_set_map_pixel_list_attach_idxs +( struct bin_pixel_node_t* default_pixel_list, + struct bin_pixel_node_t* map_pixel_list +) +{ struct bin_pixel_node_t* mapiter, defaultiter; + mapiter = map_pixel_list; + defaultiter = default_pixel_list; + while (mapiter && defaultiter) + { /* if mapiter.data.ref == defaultiter.data.ref, assign mapiter index_idx to defaultiter */ + if (mapiter.data.ref == defauliter.data.ref) + { defaultiter.data.attach_idx = mapiter.data.attach_idx; + mapiter = mapiter->next; + defaultiter = defaultiter->next; + } + else + defaultiter = defaultiter->next; + } +} + +/* map_pixel_list cannot have more pixels. for all of its pixels, + the refs must be represented in default pixel list. 0 if invalid, 1 if valid */ +static inline +int bin_valid_map_pixel_list +( struct bin_pixel_node_t* default_pixel_list, + struct bin_pixel_node_t* map_pixel_list +) +{ struct bin_pixel_node_t* mapiter, defaultiter; + defaultiter = default_pixel_list; + /* check length of each to make sure default < max */ + /* for each pixel node in default and map */ + while(defaultiter) + { for( mapiter = map_pixel_list; mapiter != NULL; mapiter = mapiter->next) + { + } + } + + if(!mapiter && defaultiter) //defaultiter is longer so error! + return 0; + + + + +} +static inline +int bin_process_map_pixel_list +( struct bin_pixel_node_t* default_pixel_list, + struct bin_pixel_node_t* map_pixel_list +) +{ /* Determine if pixel_list is valid */ + + /* Determine attach_idx of each pixel, as compared to default pixel list */ + +} +void +bin_assign_pixel_idxs +( struct bin_pixel_node_t* pixel_list ) +{ +} /* Insert pixel(s) into the list, z sorted */ -void +/* number the pixels as you insert them */ +struct bin_pixel_node_t* bin_insert_node_into_list ( struct bin_pixel_node_t* pixel_list_root, struct bin_pixel_node_t* pixel_node ) -{ struct bin_pixel_node_t* head_node, *prev_node; - int node_z; +{ struct bin_pixel_node_t* head_node, * prev_node; - head_node = pixel_list_root->next; - node_z = pixel_node->data.z; - if(head_node == NULL) - { head_node = pixel_node; + if(pixel_list_root == NULL) + { pixel_list_root = pixel_node; } - prev_node = pixel_list_root; + + prev_node = head_node = pixel_list_root; while(head_node != NULL) - { if(node_z > head_node->data.z) - { prev_node = head_node; - head_node = head_node->next; + { if(pixel_node->data.z > head_node->data.z) + { if(head_node->next) + { prev_node = head_node; + head_node = head_node->next; + } + else + { head_node->next = pixel_node; + break; + } } - else if (node_z < head_node->data.z || node_z == head_node->data.z) + else if (pixel_node->data.z < head_node->data.z || pixel_node->data.z == head_node->data.z) { prev_node->next = pixel_node; pixel_node->next = head_node; break; } } + return pixel_list_root; -} -/* TODO: Finish this */ -struct bin_pixel_node_t* -bin_process_pixel -( unsigned char* data, - int x, - int y, - int init_height, - int init_width -) -{ struct bin_pixel_node_t* pixel_node; - - - pixel_node = struct_alloc(bin_pixel_node_t); - - if(data) - { /* get ref from 4 bytes of data */ - pixel_node->data.ref = (int) data; - /* bitshift by ? to get Z ordering */ - - /* set x and y */ - pixel_node->data.x = x + init_width ; - pixel_node->data.y = y + init_width; - data += 4; - } - else - { data += 4; //TODO: does this correctly increment past 0x00000000? - return NULL; - } - - - - return pixel_node; - } -/* Returns the non null pixels of a single frame */ +/* Returns the non null pixels of a single map */ /* TODO: Finish this */ struct bin_pixel_node_t* -bin_map_to_pixel_list +bin_mapframe_to_pixel_list ( struct bin_img_info_t* img_info, int init_height, int init_width, - unsigned char* data + RBGA_t* data ) -{ int x, y; - struct bin_pixel_node_t* pixel_list, * pixel_node; +{ int x, y, fheight, fwidth; + struct bin_pixel_node_t* pixel_list,* pixel_node; pixel_list = NULL; - /* Check if frame clips */ + /* if frame clips, process unclippign frames */ if( img_info->unaligned_width ) - ; + { if(img_info->height < img_info->fheight) + fheight = img_info->height; + else + fheight = img_info->fheight; + } + else + fheight = img_info->fheight; if (img_info->unaligned_height ) - ; + { if(img_info->width < img_info->fwidth) + fwidth = img_info->width; + else + fwidth = img_info->fwidth; + } + else + fwidth = img_info->fwidth; + /* Process the map*/ - for (y = 0; y < img_info->fheight; y++) - { for ( x = 0; x < img_info->fwidth; x++ ) - { pixel_node = bin_process_pixel(data, x, y, init_height, init_width); - bin_insert_node_into_list(pixel_list, pixel_node); - } + for (y = 0; y < fheight; y++) + { for ( x = 0; x < fwidth; x++ ) + { if (*data) + { pixel_node = struct_alloc(bin_pixel_node_t); + /* get ref from 4 bytes of data */ + pixel_node->data.ref = (*data) >> 8; + /* bitshift by ? to get Z */ + pixel_node->data.z = (*data & 0xFF); + /* set x and y */ + pixel_node->data.x = x + init_width; + pixel_node->data.y = y + init_width; + pixel_list = bin_insert_node_into_list(pixel_list, pixel_node); + } + data++; + } + data += img_info->width - img_info->fwidth; //stride } - - return pixel_node; + return pixel_list; } static inline @@ -784,7 +974,7 @@ bin_cmp_default_pixel_lists ( struct bin_pixel_node_t* pl1, struct bin_pixel_node_t* pl2 ) -{ struct bin_pixel_node_t* pl1p, * pl2p; +{ struct bin_pixel_node_t* pl1p, * pl2p; int i, pl1_len, pl2_len; pl1p = pl1; @@ -814,16 +1004,16 @@ bin_find_default_pixel_list ( ir_set set) { ir_setdata fiter; struct bin_pixel_node_t* default_pixel_list, * curr_pixel_list; - unsigned char* data; + RGBA_t* data; int num_channels; struct bin_img_info_t img_info; - for (fiter = get_set_frameboxes(set); fiter != NULL; fiter = get_framebox_nextsib(fiter)) + for (fiter = ir_set_framebox(set); fiter != NULL; fiter = ir_setdata_nextsib(fiter)) { /* TODO: Stringify the frame name with .png? */ /* TODO: Add directory changing */ - data = stbi_load(get_framedata_name(get_framebox_facing_mapdata(fiter, SFACE)), &img_info.width, &img_info.width, &num_channels, 0); - bin_set_img_info(&img_info, get_framebox_facing_mapdata(fiter, SFACE)); - curr_pixel_list = bin_map_to_pixel_list(&img_info, 0, 0, data); + data = (RGBA_t*) stbi_load(ir_setdata_name((ir_setdata) ir_framebox_mapsheet(fiter,SFACE) ), &img_info.width, &img_info.width, &num_channels, 0); + bin_set_img_info(&img_info, ir_framebox_mapsheet(fiter, SFACE)); + curr_pixel_list = bin_mapframe_to_pixel_list(&img_info, 0, 0, data); default_pixel_list = bin_cmp_default_pixel_lists(curr_pixel_list, default_pixel_list); free(data);