modules/nie.c

   1 // This file is part of Deark.
   2 // Copyright (C) 2020 Jason Summers
   3 // See the file COPYING for terms of use.
   4
   5 // NIE - One of the "Naive Image Formats" used with the Wuffs project.
   6
   7 #include <deark-config.h>
   8 #include <deark-private.h>
   9 DE_DECLARE_MODULE(de_module_nie);
  10
  11 typedef struct localctx_struct {
  12 #define SIG_NIA 0x6ec3af41U
  13 #define SIG_NIE 0x6ec3af45U
  14 #define SIG_NII 0x6ec3af49U
  15         unsigned int sig;
  16         const char *fmtname;
  17         int is_bgra;
  18         int premultiplied_alpha;
  19         i64 bytes_per_pixel;
  20         i64 width, height;
  21         int bad_image_flag;
  22         int found_last_frame_flag;
  23 } lctx;
  24
  25 static u8 unpremultiply_alpha(u8 cval, u8 a)
  26 {
  27         if(a==0xff) {
  28                 return cval;
  29         }
  30         if(a==0 || cval==0) {
  31                 return 0;
  32         }
  33         if(cval>=a) {
  34                 return 0xff;
  35         }
  36         return (u8)(0.5 + (double)cval / ((double)a/255.0));
  37 }
  38
  39 // 8-byte "NII payload"
  40 static void read_NIIpayload(deark *c, lctx *d, i64 pos, int printCCD)
  41 {
  42         u64 ccd_code;
  43         i64 ccd;
  44
  45         ccd_code = dbuf_getu64le(c->infile, pos);
  46         if(ccd_code & 0x1) {
  47                 d->found_last_frame_flag = 1;
  48         }
  49         if(printCCD) {
  50                 ccd = (i64)(ccd_code>>2);
  51                 de_dbg(c, "CCD: %"I64_FMT" (%f seconds)", ccd,
  52                         (double)ccd/705600000.0);
  53         }
  54 }
  55
  56 // Decode the header, after the 4-byte signature.
  57 // That's 12 bytes for NIE, 20 bytes for NII/NIA.
  58 // On parse error, prints an error and returns 0.
  59 // If the image has invalid attributes, sets d->bad_image_flag (only NIE cares
  60 // about this).
  61 static int do_header(deark *c, lctx *d, i64 pos)
  62 {
  63         u8 b;
  64
  65         b = de_getbyte_p(&pos);
  66         if(b!=0xff) {
  67                 de_err(c, "Unknown %s version", d->fmtname);
  68                 return 0;
  69         }
  70
  71         if(d->sig==SIG_NII) {
  72                 pos += 3; // padding
  73         }
  74         else {
  75                 b = de_getbyte_p(&pos);
  76                 if(b=='b') {
  77                         d->is_bgra = 1;
  78                 }
  79                 else if(b!='r') {
  80                         d->bad_image_flag = 1;
  81                 }
  82                 de_dbg(c, "sample order: %sA", (d->is_bgra?"BGR":"RGB"));
  83
  84                 b = de_getbyte_p(&pos);
  85                 if(b=='p') {
  86                         d->premultiplied_alpha = 1;
  87                 }
  88                 else if(b!='n') {
  89                         d->bad_image_flag = 1;
  90                 }
  91                 de_dbg(c, "premultiplied alpha: %d", d->premultiplied_alpha);
  92
  93                 b = de_getbyte_p(&pos);
  94                 if(b=='8') {
  95                         d->bytes_per_pixel = 8;
  96                 }
  97                 else if(b=='4') {
  98                         d->bytes_per_pixel = 4;
  99                 }
 100                 else {
 101                         d->bad_image_flag = 1;
 102                 }
 103                 de_dbg(c, "bytes/pixel: %d", (int)d->bytes_per_pixel);
 104         }
 105
 106         d->width = de_getu32le_p(&pos);
 107         d->height = de_getu32le_p(&pos);
 108         de_dbg_dimensions(c, d->width, d->height);
 109
 110         if(d->sig==SIG_NIE) return 1;
 111
 112         read_NIIpayload(c, d, pos, 0);
 113         return 1;
 114 }
 115
 116 static void do_decode_nie(deark *c, lctx *d)
 117 {
 118         i64 i, j;
 119         i64 k;
 120         i64 pos = 0;
 121         i64 sample_offset[4]; // R, G, B, A
 122         de_bitmap *img = NULL;
 123
 124         pos += 4; // signature, already read
 125
 126         if(!do_header(c, d, pos)) goto done;
 127         if(d->bad_image_flag) {
 128                 de_err(c, "Bad or unsupported NIE format");
 129                 goto done;
 130         }
 131         pos += 12;
 132
 133         if(!de_good_image_dimensions(c, d->width, d->height)) {
 134                 goto done;
 135         }
 136
 137         // Make a sample-to-byte-offset map.
 138         for(k=0; k<4; k++) {
 139                 sample_offset[k] = k; // Defaults
 140         }
 141         if(d->is_bgra) {
 142                 sample_offset[0] = 2; // R sample is byte 2
 143                 sample_offset[2] = 0; // B sample is byte 0
 144         }
 145         if(d->bytes_per_pixel==8) { // If 16 bits/sample, look only at the high byte
 146                 for(k=0; k<4; k++) {
 147                         sample_offset[k] = sample_offset[k]*2 + 1;
 148                 }
 149         }
 150
 151         img = de_bitmap_create(c, d->width, d->height, 4);
 152
 153         for(j=0; j<d->height; j++) {
 154                 for(i=0; i<d->width; i++) {
 155                         u8 pbuf[8];
 156                         u8 s[4];
 157
 158                         de_read(pbuf, pos, d->bytes_per_pixel);
 159                         pos += d->bytes_per_pixel;
 160
 161                         for(k=0; k<4; k++) {
 162                                 s[k] = pbuf[sample_offset[k]];
 163                         }
 164
 165                         if(d->premultiplied_alpha && (s[3]!=0xff)) {
 166                                 for(k=0; k<3; k++) {
 167                                         s[k] = unpremultiply_alpha(s[k], s[3]);
 168                                 }
 169                         }
 170
 171                         de_bitmap_setpixel_rgba(img, i, j, DE_MAKE_RGBA(s[0],s[1],s[2],s[3]));
 172                 }
 173         }
 174
 175         de_bitmap_write_to_file(img, NULL, DE_CREATEFLAG_OPT_IMAGE);
 176
 177 done:
 178         de_bitmap_destroy(img);
 179 }
 180
 181 static void do_decode_nii(deark *c, lctx *d)
 182 {
 183         i64 pos = 4;
 184
 185         if(!do_header(c, d, pos)) goto done;
 186         pos += 20;
 187
 188         while(1) {
 189                 if(d->found_last_frame_flag) break;
 190                 de_dbg(c, "frame info at %"I64_FMT, pos);
 191                 de_dbg_indent(c, 1);
 192                 read_NIIpayload(c, d, pos, 1);
 193                 pos += 8;
 194                 de_dbg_indent(c, -1);
 195         }
 196         // TODO?: footer
 197 done:
 198         ;
 199 }
 200
 201 static void do_decode_nia(deark *c, lctx *d)
 202 {
 203         i64 pos = 4;
 204         i64 frame_size, frame_size_padded;
 205
 206         if(!do_header(c, d, pos)) goto done;
 207         pos += 20;
 208
 209         frame_size = 16 + d->width*d->height*d->bytes_per_pixel;
 210         de_dbg(c, "frame size: %"I64_FMT" bytes", frame_size);
 211         if(frame_size<16 || frame_size>DE_MAX_SANE_OBJECT_SIZE) {
 212                 goto done;
 213         }
 214         frame_size_padded = de_pad_to_n(frame_size, 8);
 215
 216         while(1) {
 217                 if(d->found_last_frame_flag) break;
 218                 if(pos+frame_size_padded > c->infile->len) goto done;
 219                 de_dbg(c, "frame at %"I64_FMT, pos);
 220                 de_dbg_indent(c, 1);
 221                 dbuf_create_file_from_slice(c->infile, pos, frame_size, "nie", NULL, 0x0);
 222                 pos += frame_size_padded;
 223                 read_NIIpayload(c, d, pos, 1);
 224                 pos += 8;
 225                 de_dbg_indent(c, -1);
 226         }
 227         // TODO?: footer
 228 done:
 229         ;
 230 }
 231
 232 static void de_run_nie(deark *c, de_module_params *mparams)
 233 {
 234         lctx *d = NULL;
 235
 236         d = de_malloc(c, sizeof(lctx));
 237         d->sig = (unsigned int)de_getu32be(0);
 238
 239         if(d->sig==SIG_NIE) {
 240                 d->fmtname = "NIE";
 241         }
 242         else if(d->sig==SIG_NII) {
 243                 d->fmtname = "NII";
 244         }
 245         else if(d->sig==SIG_NIA) {
 246                 d->fmtname = "NIA";
 247         }
 248         else {
 249                 de_err(c, "File not in NIE/NII/NIA format");
 250                 goto done;
 251         }
 252
 253         de_declare_fmt(c, d->fmtname);
 254
 255         if(d->sig==SIG_NIE) {
 256                 do_decode_nie(c, d);
 257         }
 258         else if(d->sig==SIG_NII) {
 259                 do_decode_nii(c, d);
 260         }
 261         else if(d->sig==SIG_NIA) {
 262                 do_decode_nia(c, d);
 263         }
 264
 265 done:
 266         de_free(c, d);
 267 }
 268
 269 static int de_identify_nie(deark *c)
 270 {
 271         unsigned int sig;
 272
 273         sig = (unsigned int)de_getu32be(0);
 274         if(sig==SIG_NIE || sig==SIG_NII || sig==SIG_NIA) return 100;
 275         return 0;
 276 }
 277
 278 void de_module_nie(deark *c, struct deark_module_info *mi)
 279 {
 280         mi->id = "nie";
 281         mi->desc = "NIE/NII/NIA (Naive Image Formats)";
 282         mi->run_fn = de_run_nie;
 283         mi->identify_fn = de_identify_nie;
 284 }