modules/nokia.c

   1 // This file is part of Deark.
   2 // Copyright (C) 2016 Jason Summers
   3 // See the file COPYING for terms of use.
   4
   5 // Various Nokia phone image formats
   6
   7 #include <deark-config.h>
   8 #include <deark-private.h>
   9 #include <deark-fmtutil.h>
  10 DE_DECLARE_MODULE(de_module_nol);
  11 DE_DECLARE_MODULE(de_module_ngg);
  12 DE_DECLARE_MODULE(de_module_npm);
  13 DE_DECLARE_MODULE(de_module_nlm);
  14 DE_DECLARE_MODULE(de_module_nsl);
  15
  16 typedef struct localctx_struct {
  17         i64 w, h;
  18         int done_flag;
  19 } lctx;
  20
  21 // **************************************************************************
  22 // Nokia Operator Logo (NOL)
  23 //
  24 // Caution: This code is not based on any official specifications.
  25 // **************************************************************************
  26
  27 static void nol_ngg_read_bitmap(deark *c, lctx *d, i64 pos)
  28 {
  29         de_bitmap *img = NULL;
  30         i64 i, j;
  31         u8 n;
  32
  33         img = de_bitmap_create(c, d->w, d->h, 1);
  34
  35         for(j=0; j<d->h; j++) {
  36                 for(i=0; i<d->w; i++) {
  37                         n = de_getbyte(pos);
  38                         pos++;
  39                         de_bitmap_setpixel_gray(img, i, j, n=='0' ? 255 : 0);
  40                 }
  41         }
  42
  43         de_bitmap_write_to_file(img, NULL, 0);
  44         de_bitmap_destroy(img);
  45 }
  46
  47 static void de_run_nol(deark *c, de_module_params *mparams)
  48 {
  49         lctx *d = NULL;
  50
  51         d = de_malloc(c, sizeof(lctx));
  52
  53         d->w = de_getu16le(10);
  54         d->h = de_getu16le(12);
  55         de_dbg_dimensions(c, d->w, d->h);
  56         if(!de_good_image_dimensions(c, d->w, d->h)) goto done;
  57
  58         nol_ngg_read_bitmap(c, d, 20);
  59 done:
  60         de_free(c, d);
  61 }
  62
  63 static int de_identify_nol(deark *c)
  64 {
  65         if(!dbuf_memcmp(c->infile, 0, "NOL", 3)) return 80;
  66         return 0;
  67 }
  68
  69 void de_module_nol(deark *c, struct deark_module_info *mi)
  70 {
  71         mi->id = "nol";
  72         mi->desc = "Nokia Operator Logo";
  73         mi->run_fn = de_run_nol;
  74         mi->identify_fn = de_identify_nol;
  75 }
  76
  77 // **************************************************************************
  78 // Nokia Group Graphic (NGG)
  79 //
  80 // Caution: This code is not based on any official specifications.
  81 // **************************************************************************
  82
  83 static void de_run_ngg(deark *c, de_module_params *mparams)
  84 {
  85         lctx *d = NULL;
  86
  87         d = de_malloc(c, sizeof(lctx));
  88
  89         d->w = de_getu16le(6);
  90         d->h = de_getu16le(8);
  91         de_dbg_dimensions(c, d->w, d->h);
  92         if(!de_good_image_dimensions(c, d->w, d->h)) goto done;
  93
  94         nol_ngg_read_bitmap(c, d, 16);
  95 done:
  96         de_free(c, d);
  97 }
  98
  99 static int de_identify_ngg(deark *c)
 100 {
 101         if(!dbuf_memcmp(c->infile, 0, "NGG", 3)) return 80;
 102         return 0;
 103 }
 104
 105 void de_module_ngg(deark *c, struct deark_module_info *mi)
 106 {
 107         mi->id = "ngg";
 108         mi->desc = "Nokia Group Graphic";
 109         mi->run_fn = de_run_ngg;
 110         mi->identify_fn = de_identify_ngg;
 111 }
 112
 113 // **************************************************************************
 114 // Nokia Picture Message (NPM)
 115 //
 116 // Caution: This code is not based on any official specifications.
 117 // **************************************************************************
 118
 119 static void npm_nlm_read_bitmap(deark *c, lctx *d, i64 pos)
 120 {
 121         de_convert_and_write_image_bilevel2(c->infile, pos, d->w, d->h, (d->w+7)/8,
 122                 DE_CVTF_WHITEISZERO, NULL, 0);
 123 }
 124
 125 static void de_run_npm(deark *c, de_module_params *mparams)
 126 {
 127         i64 txt_len;
 128         i64 pos;
 129         lctx *d = NULL;
 130         de_ucstring *s = NULL;
 131
 132         d = de_malloc(c, sizeof(lctx));
 133
 134         pos = 4;
 135         txt_len = (i64)de_getbyte_p(&pos);
 136         de_dbg(c, "text length: %d", (int)txt_len);
 137         if(txt_len>0) {
 138                 s = ucstring_create(c);
 139                 dbuf_read_to_ucstring(c->infile, pos, txt_len, s, 0, DE_ENCODING_ASCII);
 140                 de_dbg(c, "text: \"%s\"", ucstring_getpsz_d(s));
 141                 pos += txt_len;
 142         }
 143         pos += 1;
 144
 145         d->w = (i64)de_getbyte_p(&pos);
 146         d->h = (i64)de_getbyte_p(&pos);
 147         de_dbg_dimensions(c, d->w, d->h);
 148
 149         pos += 3;
 150         npm_nlm_read_bitmap(c, d, pos);
 151
 152         ucstring_destroy(s);
 153         de_free(c, d);
 154 }
 155
 156 static int de_identify_npm(deark *c)
 157 {
 158         if(!dbuf_memcmp(c->infile, 0, "NPM", 3)) return 80;
 159         return 0;
 160 }
 161
 162 void de_module_npm(deark *c, struct deark_module_info *mi)
 163 {
 164         mi->id = "npm";
 165         mi->desc = "Nokia Picture Message";
 166         mi->run_fn = de_run_npm;
 167         mi->identify_fn = de_identify_npm;
 168 }
 169
 170 // **************************************************************************
 171 // Nokia Logo Manager bitmap (NLM)
 172 //
 173 // Caution: This code is not based on any official specifications.
 174 // **************************************************************************
 175
 176 static void de_run_nlm(deark *c, de_module_params *mparams)
 177 {
 178         lctx *d = NULL;
 179         u8 imgtype;
 180         const char *s;
 181
 182         d = de_malloc(c, sizeof(lctx));
 183
 184         imgtype = de_getbyte(5);
 185         switch(imgtype) {
 186         case 0: s="Operator logo"; break;
 187         case 1: s="Caller logo"; break;
 188         case 2: s="Startup logo"; break;
 189         case 3: s="Picture image logo"; break;
 190         default: s="unknown";
 191         }
 192         de_dbg(c, "image type: %d (%s)", (int)imgtype, s);
 193
 194         d->w = (i64)de_getbyte(7);
 195         d->h = (i64)de_getbyte(8);
 196         de_dbg_dimensions(c, d->w, d->h);
 197
 198         npm_nlm_read_bitmap(c, d, 10);
 199
 200         de_free(c, d);
 201 }
 202
 203 static int de_identify_nlm(deark *c)
 204 {
 205         if(!dbuf_memcmp(c->infile, 0, "NLM ", 4)) return 80;
 206         return 0;
 207 }
 208
 209 void de_module_nlm(deark *c, struct deark_module_info *mi)
 210 {
 211         mi->id = "nlm";
 212         mi->desc = "Nokia Logo Manager bitmap";
 213         mi->run_fn = de_run_nlm;
 214         mi->identify_fn = de_identify_nlm;
 215 }
 216
 217 // **************************************************************************
 218 // Nokia Startup Logo (NSL)
 219 //
 220 // Caution: This code is not based on any official specifications.
 221 // **************************************************************************
 222
 223
 224 static void nsl_read_bitmap(deark *c, lctx *d, i64 pos, i64 len)
 225 {
 226         de_bitmap *img = NULL;
 227         i64 i, j;
 228         u8 x;
 229
 230         de_dbg(c, "bitmap at %d, len=%d", (int)pos, (int)len);
 231         d->done_flag = 1;
 232
 233         if(len!=504) {
 234                 de_err(c, "Unsupported NSL version (bitmap size=%d)", (int)len);
 235                 goto done;
 236         }
 237
 238         d->w = 84;
 239         d->h = 48;
 240
 241         img = de_bitmap_create(c, d->w, d->h, 1);
 242
 243         for(j=0; j<d->h; j++) {
 244                 for(i=0; i<d->w; i++) {
 245                         x = de_getbyte(pos + (j/8)*d->w + i);
 246                         x = x & (1<<(j%8));
 247                         if(x==0)
 248                                 de_bitmap_setpixel_gray(img, i, j, 255);
 249                 }
 250         }
 251
 252         de_bitmap_write_to_file(img, NULL, 0);
 253
 254 done:
 255         de_bitmap_destroy(img);
 256 }
 257
 258 #define CODE_FORM  0x464f524dU
 259 #define CODE_NSLD  0x4e534c44U
 260
 261 static int my_nsl_chunk_handler(struct de_iffctx *ictx)
 262 {
 263         deark *c = ictx->c;
 264         lctx *d = (lctx*)ictx->userdata;
 265
 266         if(ictx->chunkctx->chunk4cc.id == CODE_FORM) {
 267                 ictx->is_raw_container = 1;
 268                 return 1;
 269         }
 270
 271         switch(ictx->chunkctx->chunk4cc.id) {
 272         case CODE_NSLD:
 273                 if(ictx->level==1 && !d->done_flag) {
 274                         nsl_read_bitmap(c, d, ictx->chunkctx->dpos, ictx->chunkctx->dlen);
 275                 }
 276                 ictx->handled = 1;
 277                 break;
 278         }
 279
 280         return 1;
 281 }
 282
 283 static void de_run_nsl(deark *c, de_module_params *mparams)
 284 {
 285         lctx *d = NULL;
 286         struct de_iffctx *ictx = NULL;
 287
 288         d = de_malloc(c, sizeof(lctx));
 289         ictx = fmtutil_create_iff_decoder(c);
 290
 291         ictx->userdata = (void*)d;
 292         ictx->handle_chunk_fn = my_nsl_chunk_handler;
 293         ictx->f = c->infile;
 294         ictx->sizeof_len = 2;
 295
 296         fmtutil_read_iff_format(ictx, 0, c->infile->len);
 297
 298         fmtutil_destroy_iff_decoder(ictx);
 299         de_free(c, d);
 300 }
 301
 302 static int de_identify_nsl(deark *c)
 303 {
 304         i64 x;
 305
 306         // NSL uses a variant of IFF, which is not so easy to identify.
 307         // (TODO: Write an IFF format detector.)
 308
 309         if(dbuf_memcmp(c->infile, 0, "FORM", 4)) return 0;
 310
 311         x = de_getu16be(4);
 312         if(x+6 != c->infile->len) return 0;
 313
 314         if(de_input_file_has_ext(c, "nsl")) {
 315                 return 100;
 316         }
 317         return 10;
 318 }
 319
 320 void de_module_nsl(deark *c, struct deark_module_info *mi)
 321 {
 322         mi->id = "nsl";
 323         mi->desc = "Nokia Startup Logo";
 324         mi->run_fn = de_run_nsl;
 325         mi->identify_fn = de_identify_nsl;
 326 }