src/lib/openjp3d/mqc.c

   1 /*
   2  * The copyright in this software is being made available under the 2-clauses
   3  * BSD License, included below. This software may be subject to other third
   4  * party and contributor rights, including patent rights, and no such rights
   5  * are granted under this license.
   6  *
   7  * Copyright (c) 2001-2003, David Janssens
   8  * Copyright (c) 2002-2003, Yannick Verschueren
   9  * Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
  10  * Copyright (c) 2005, Herve Drolon, FreeImage Team
  11  * Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
  12  * All rights reserved.
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions
  16  * are met:
  17  * 1. Redistributions of source code must retain the above copyright
  18  *    notice, this list of conditions and the following disclaimer.
  19  * 2. Redistributions in binary form must reproduce the above copyright
  20  *    notice, this list of conditions and the following disclaimer in the
  21  *    documentation and/or other materials provided with the distribution.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  24  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  31  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33  * POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 #include "opj_includes.h"
  37
  38 /** @defgroup MQC MQC - Implementation of an MQ-Coder */
  39 /*@{*/
  40
  41 /** @name Local static functions */
  42 /*@{*/
  43
  44 /**
  45 Output a byte, doing bit-stuffing if necessary.
  46 After a 0xff byte, the next byte must be smaller than 0x90.
  47 @param mqc MQC handle
  48 */
  49 static void mqc_byteout(opj_mqc_t *mqc);
  50 /**
  51 Renormalize mqc->a and mqc->c while encoding, so that mqc->a stays between 0x8000 and 0x10000
  52 @param mqc MQC handle
  53 */
  54 static void mqc_renorme(opj_mqc_t *mqc);
  55 /**
  56 Encode the most probable symbol
  57 @param mqc MQC handle
  58 */
  59 static void mqc_codemps(opj_mqc_t *mqc);
  60 /**
  61 Encode the most least symbol
  62 @param mqc MQC handle
  63 */
  64 static void mqc_codelps(opj_mqc_t *mqc);
  65 /**
  66 Fill mqc->c with 1's for flushing
  67 @param mqc MQC handle
  68 */
  69 static void mqc_setbits(opj_mqc_t *mqc);
  70 /**
  71 Exchange MPS with LPS
  72 @param mqc MQC handle
  73 @return
  74 */
  75 static int mqc_mpsexchange(opj_mqc_t *mqc);
  76 /**
  77 Exchange LPS with MPS
  78 @param mqc MQC handle
  79 @return
  80 */
  81 static int mqc_lpsexchange(opj_mqc_t *mqc);
  82 /**
  83 Input a byte
  84 @param mqc MQC handle
  85 */
  86 static void mqc_bytein(opj_mqc_t *mqc);
  87 /**
  88 Renormalize mqc->a and mqc->c while decoding
  89 @param mqc MQC handle
  90 */
  91 static void mqc_renormd(opj_mqc_t *mqc);
  92
  93 /*@}*/
  94
  95 /*@}*/
  96
  97 /* <summary> */
  98 /* This array defines all the possible states for a context. */
  99 /* </summary> */
 100 static opj_mqc_state_t mqc_states[47 * 2] = {
 101     {0x5601, 0, &mqc_states[2], &mqc_states[3]},
 102     {0x5601, 1, &mqc_states[3], &mqc_states[2]},
 103     {0x3401, 0, &mqc_states[4], &mqc_states[12]},
 104     {0x3401, 1, &mqc_states[5], &mqc_states[13]},
 105     {0x1801, 0, &mqc_states[6], &mqc_states[18]},
 106     {0x1801, 1, &mqc_states[7], &mqc_states[19]},
 107     {0x0ac1, 0, &mqc_states[8], &mqc_states[24]},
 108     {0x0ac1, 1, &mqc_states[9], &mqc_states[25]},
 109     {0x0521, 0, &mqc_states[10], &mqc_states[58]},
 110     {0x0521, 1, &mqc_states[11], &mqc_states[59]},
 111     {0x0221, 0, &mqc_states[76], &mqc_states[66]},
 112     {0x0221, 1, &mqc_states[77], &mqc_states[67]},
 113     {0x5601, 0, &mqc_states[14], &mqc_states[13]},
 114     {0x5601, 1, &mqc_states[15], &mqc_states[12]},
 115     {0x5401, 0, &mqc_states[16], &mqc_states[28]},
 116     {0x5401, 1, &mqc_states[17], &mqc_states[29]},
 117     {0x4801, 0, &mqc_states[18], &mqc_states[28]},
 118     {0x4801, 1, &mqc_states[19], &mqc_states[29]},
 119     {0x3801, 0, &mqc_states[20], &mqc_states[28]},
 120     {0x3801, 1, &mqc_states[21], &mqc_states[29]},
 121     {0x3001, 0, &mqc_states[22], &mqc_states[34]},
 122     {0x3001, 1, &mqc_states[23], &mqc_states[35]},
 123     {0x2401, 0, &mqc_states[24], &mqc_states[36]},
 124     {0x2401, 1, &mqc_states[25], &mqc_states[37]},
 125     {0x1c01, 0, &mqc_states[26], &mqc_states[40]},
 126     {0x1c01, 1, &mqc_states[27], &mqc_states[41]},
 127     {0x1601, 0, &mqc_states[58], &mqc_states[42]},
 128     {0x1601, 1, &mqc_states[59], &mqc_states[43]},
 129     {0x5601, 0, &mqc_states[30], &mqc_states[29]},
 130     {0x5601, 1, &mqc_states[31], &mqc_states[28]},
 131     {0x5401, 0, &mqc_states[32], &mqc_states[28]},
 132     {0x5401, 1, &mqc_states[33], &mqc_states[29]},
 133     {0x5101, 0, &mqc_states[34], &mqc_states[30]},
 134     {0x5101, 1, &mqc_states[35], &mqc_states[31]},
 135     {0x4801, 0, &mqc_states[36], &mqc_states[32]},
 136     {0x4801, 1, &mqc_states[37], &mqc_states[33]},
 137     {0x3801, 0, &mqc_states[38], &mqc_states[34]},
 138     {0x3801, 1, &mqc_states[39], &mqc_states[35]},
 139     {0x3401, 0, &mqc_states[40], &mqc_states[36]},
 140     {0x3401, 1, &mqc_states[41], &mqc_states[37]},
 141     {0x3001, 0, &mqc_states[42], &mqc_states[38]},
 142     {0x3001, 1, &mqc_states[43], &mqc_states[39]},
 143     {0x2801, 0, &mqc_states[44], &mqc_states[38]},
 144     {0x2801, 1, &mqc_states[45], &mqc_states[39]},
 145     {0x2401, 0, &mqc_states[46], &mqc_states[40]},
 146     {0x2401, 1, &mqc_states[47], &mqc_states[41]},
 147     {0x2201, 0, &mqc_states[48], &mqc_states[42]},
 148     {0x2201, 1, &mqc_states[49], &mqc_states[43]},
 149     {0x1c01, 0, &mqc_states[50], &mqc_states[44]},
 150     {0x1c01, 1, &mqc_states[51], &mqc_states[45]},
 151     {0x1801, 0, &mqc_states[52], &mqc_states[46]},
 152     {0x1801, 1, &mqc_states[53], &mqc_states[47]},
 153     {0x1601, 0, &mqc_states[54], &mqc_states[48]},
 154     {0x1601, 1, &mqc_states[55], &mqc_states[49]},
 155     {0x1401, 0, &mqc_states[56], &mqc_states[50]},
 156     {0x1401, 1, &mqc_states[57], &mqc_states[51]},
 157     {0x1201, 0, &mqc_states[58], &mqc_states[52]},
 158     {0x1201, 1, &mqc_states[59], &mqc_states[53]},
 159     {0x1101, 0, &mqc_states[60], &mqc_states[54]},
 160     {0x1101, 1, &mqc_states[61], &mqc_states[55]},
 161     {0x0ac1, 0, &mqc_states[62], &mqc_states[56]},
 162     {0x0ac1, 1, &mqc_states[63], &mqc_states[57]},
 163     {0x09c1, 0, &mqc_states[64], &mqc_states[58]},
 164     {0x09c1, 1, &mqc_states[65], &mqc_states[59]},
 165     {0x08a1, 0, &mqc_states[66], &mqc_states[60]},
 166     {0x08a1, 1, &mqc_states[67], &mqc_states[61]},
 167     {0x0521, 0, &mqc_states[68], &mqc_states[62]},
 168     {0x0521, 1, &mqc_states[69], &mqc_states[63]},
 169     {0x0441, 0, &mqc_states[70], &mqc_states[64]},
 170     {0x0441, 1, &mqc_states[71], &mqc_states[65]},
 171     {0x02a1, 0, &mqc_states[72], &mqc_states[66]},
 172     {0x02a1, 1, &mqc_states[73], &mqc_states[67]},
 173     {0x0221, 0, &mqc_states[74], &mqc_states[68]},
 174     {0x0221, 1, &mqc_states[75], &mqc_states[69]},
 175     {0x0141, 0, &mqc_states[76], &mqc_states[70]},
 176     {0x0141, 1, &mqc_states[77], &mqc_states[71]},
 177     {0x0111, 0, &mqc_states[78], &mqc_states[72]},
 178     {0x0111, 1, &mqc_states[79], &mqc_states[73]},
 179     {0x0085, 0, &mqc_states[80], &mqc_states[74]},
 180     {0x0085, 1, &mqc_states[81], &mqc_states[75]},
 181     {0x0049, 0, &mqc_states[82], &mqc_states[76]},
 182     {0x0049, 1, &mqc_states[83], &mqc_states[77]},
 183     {0x0025, 0, &mqc_states[84], &mqc_states[78]},
 184     {0x0025, 1, &mqc_states[85], &mqc_states[79]},
 185     {0x0015, 0, &mqc_states[86], &mqc_states[80]},
 186     {0x0015, 1, &mqc_states[87], &mqc_states[81]},
 187     {0x0009, 0, &mqc_states[88], &mqc_states[82]},
 188     {0x0009, 1, &mqc_states[89], &mqc_states[83]},
 189     {0x0005, 0, &mqc_states[90], &mqc_states[84]},
 190     {0x0005, 1, &mqc_states[91], &mqc_states[85]},
 191     {0x0001, 0, &mqc_states[90], &mqc_states[86]},
 192     {0x0001, 1, &mqc_states[91], &mqc_states[87]},
 193     {0x5601, 0, &mqc_states[92], &mqc_states[92]},
 194     {0x5601, 1, &mqc_states[93], &mqc_states[93]},
 195 };
 196
 197 /*
 198 ==========================================================
 199    local functions
 200 ==========================================================
 201 */
 202
 203 static void mqc_byteout(opj_mqc_t *mqc)
 204 {
 205     if (*mqc->bp == 0xff) {
 206         mqc->bp++;
 207         *mqc->bp = mqc->c >> 20;
 208         mqc->c &= 0xfffff;
 209         mqc->ct = 7;
 210     } else {
 211         if ((mqc->c & 0x8000000) == 0) {    /* ((mqc->c&0x8000000)==0) CHANGE */
 212             mqc->bp++;
 213             *mqc->bp = mqc->c >> 19;
 214             mqc->c &= 0x7ffff;
 215             mqc->ct = 8;
 216         } else {
 217             (*mqc->bp)++;
 218             if (*mqc->bp == 0xff) {
 219                 mqc->c &= 0x7ffffff;
 220                 mqc->bp++;
 221                 *mqc->bp = mqc->c >> 20;
 222                 mqc->c &= 0xfffff;
 223                 mqc->ct = 7;
 224             } else {
 225                 mqc->bp++;
 226                 *mqc->bp = mqc->c >> 19;
 227                 mqc->c &= 0x7ffff;
 228                 mqc->ct = 8;
 229             }
 230         }
 231     }
 232 }
 233
 234 static void mqc_renorme(opj_mqc_t *mqc)
 235 {
 236     do {
 237         mqc->a <<= 1;
 238         mqc->c <<= 1;
 239         mqc->ct--;
 240         if (mqc->ct == 0) {
 241             mqc_byteout(mqc);
 242         }
 243     } while ((mqc->a & 0x8000) == 0);
 244 }
 245
 246 static void mqc_codemps(opj_mqc_t *mqc)
 247 {
 248     mqc->a -= (*mqc->curctx)->qeval;
 249     if ((mqc->a & 0x8000) == 0) {
 250         if (mqc->a < (*mqc->curctx)->qeval) {
 251             mqc->a = (*mqc->curctx)->qeval;
 252         } else {
 253             mqc->c += (*mqc->curctx)->qeval;
 254         }
 255         *mqc->curctx = (*mqc->curctx)->nmps;
 256         mqc_renorme(mqc);
 257     } else {
 258         mqc->c += (*mqc->curctx)->qeval;
 259     }
 260 }
 261
 262 static void mqc_codelps(opj_mqc_t *mqc)
 263 {
 264     mqc->a -= (*mqc->curctx)->qeval;
 265     if (mqc->a < (*mqc->curctx)->qeval) {
 266         mqc->c += (*mqc->curctx)->qeval;
 267     } else {
 268         mqc->a = (*mqc->curctx)->qeval;
 269     }
 270     *mqc->curctx = (*mqc->curctx)->nlps;
 271     mqc_renorme(mqc);
 272 }
 273
 274 static void mqc_setbits(opj_mqc_t *mqc)
 275 {
 276     unsigned int tempc = mqc->c + mqc->a;
 277     mqc->c |= 0xffff;
 278     if (mqc->c >= tempc) {
 279         mqc->c -= 0x8000;
 280     }
 281 }
 282
 283 static int mqc_mpsexchange(opj_mqc_t *mqc)
 284 {
 285     int d;
 286     if (mqc->a < (*mqc->curctx)->qeval) {
 287         d = 1 - (*mqc->curctx)->mps;
 288         *mqc->curctx = (*mqc->curctx)->nlps;
 289     } else {
 290         d = (*mqc->curctx)->mps;
 291         *mqc->curctx = (*mqc->curctx)->nmps;
 292     }
 293
 294     return d;
 295 }
 296
 297 static int mqc_lpsexchange(opj_mqc_t *mqc)
 298 {
 299     int d;
 300     if (mqc->a < (*mqc->curctx)->qeval) {
 301         mqc->a = (*mqc->curctx)->qeval;
 302         d = (*mqc->curctx)->mps;
 303         *mqc->curctx = (*mqc->curctx)->nmps;
 304     } else {
 305         mqc->a = (*mqc->curctx)->qeval;
 306         d = 1 - (*mqc->curctx)->mps;
 307         *mqc->curctx = (*mqc->curctx)->nlps;
 308     }
 309
 310     return d;
 311 }
 312
 313 static void mqc_bytein(opj_mqc_t *mqc)
 314 {
 315     if (mqc->bp != mqc->end) {
 316         unsigned int c;
 317         if (mqc->bp + 1 != mqc->end) {
 318             c = *(mqc->bp + 1);
 319         } else {
 320             c = 0xff;
 321         }
 322         if (*mqc->bp == 0xff) {
 323             if (c > 0x8f) {
 324                 mqc->c += 0xff00;
 325                 mqc->ct = 8;
 326             } else {
 327                 mqc->bp++;
 328                 mqc->c += c << 9;
 329                 mqc->ct = 7;
 330             }
 331         } else {
 332             mqc->bp++;
 333             mqc->c += c << 8;
 334             mqc->ct = 8;
 335         }
 336     } else {
 337         mqc->c += 0xff00;
 338         mqc->ct = 8;
 339     }
 340 }
 341
 342 static void mqc_renormd(opj_mqc_t *mqc)
 343 {
 344     do {
 345         if (mqc->ct == 0) {
 346             mqc_bytein(mqc);
 347         }
 348         mqc->a <<= 1;
 349         mqc->c <<= 1;
 350         mqc->ct--;
 351     } while (mqc->a < 0x8000);
 352 }
 353
 354 /*
 355 ==========================================================
 356    MQ-Coder interface
 357 ==========================================================
 358 */
 359
 360 opj_mqc_t* mqc_create()
 361 {
 362     opj_mqc_t *mqc = (opj_mqc_t*)opj_malloc(sizeof(opj_mqc_t));
 363     return mqc;
 364 }
 365
 366 void mqc_destroy(opj_mqc_t *mqc)
 367 {
 368     if (mqc) {
 369         opj_free(mqc);
 370     }
 371 }
 372
 373 int mqc_numbytes(opj_mqc_t *mqc)
 374 {
 375     return mqc->bp - mqc->start;
 376 }
 377
 378 void mqc_init_enc(opj_mqc_t *mqc, unsigned char *bp)
 379 {
 380     mqc_setcurctx(mqc, 0);
 381     mqc->a = 0x8000;
 382     mqc->c = 0;
 383     mqc->bp = bp - 1;
 384     mqc->ct = 12;
 385     if (*mqc->bp == 0xff) {
 386         mqc->ct = 13;
 387     }
 388     mqc->start = bp;
 389 }
 390
 391 void mqc_setcurctx(opj_mqc_t *mqc, int ctxno)
 392 {
 393     mqc->curctx = &mqc->ctxs[ctxno];
 394 }
 395
 396 void mqc_encode(opj_mqc_t *mqc, int d)
 397 {
 398     if ((*mqc->curctx)->mps == d) {
 399         mqc_codemps(mqc);
 400     } else {
 401         mqc_codelps(mqc);
 402     }
 403 }
 404
 405 void mqc_flush(opj_mqc_t *mqc)
 406 {
 407     mqc_setbits(mqc);
 408     mqc->c <<= mqc->ct;
 409     mqc_byteout(mqc);
 410     mqc->c <<= mqc->ct;
 411     mqc_byteout(mqc);
 412
 413     if (*mqc->bp != 0xff) {
 414         mqc->bp++;
 415     }
 416 }
 417
 418 void mqc_bypass_init_enc(opj_mqc_t *mqc)
 419 {
 420     mqc->c = 0;
 421     mqc->ct = 8;
 422     /*if (*mqc->bp == 0xff) {
 423     mqc->ct = 7;
 424      } */
 425 }
 426
 427 void mqc_bypass_enc(opj_mqc_t *mqc, int d)
 428 {
 429     mqc->ct--;
 430     mqc->c = mqc->c + (d << mqc->ct);
 431     if (mqc->ct == 0) {
 432         mqc->bp++;
 433         *mqc->bp = mqc->c;
 434         mqc->ct = 8;
 435         if (*mqc->bp == 0xff) {
 436             mqc->ct = 7;
 437         }
 438         mqc->c = 0;
 439     }
 440 }
 441
 442 int mqc_bypass_flush_enc(opj_mqc_t *mqc)
 443 {
 444     unsigned char bit_padding;
 445
 446     bit_padding = 0;
 447
 448     if (mqc->ct != 0) {
 449         while (mqc->ct > 0) {
 450             mqc->ct--;
 451             mqc->c += bit_padding << mqc->ct;
 452             bit_padding = (bit_padding + 1) & 0x01;
 453         }
 454         mqc->bp++;
 455         *mqc->bp = mqc->c;
 456         mqc->ct = 8;
 457         mqc->c = 0;
 458     }
 459
 460     return 1;
 461 }
 462
 463 void mqc_reset_enc(opj_mqc_t *mqc)
 464 {
 465     mqc_resetstates(mqc);
 466     mqc_setstate(mqc, 18, 0, 46);
 467     mqc_setstate(mqc, 0, 0, 3);
 468     mqc_setstate(mqc, 1, 0, 4);
 469 }
 470
 471 void mqc_reset_enc_3(opj_mqc_t *mqc)
 472 {
 473     mqc_resetstates(mqc);
 474     mqc_setstate(mqc, T1_3D_CTXNO_UNI, 0, 46);
 475     mqc_setstate(mqc, T1_3D_CTXNO_AGG, 0, 3);
 476     mqc_setstate(mqc, T1_3D_CTXNO_ZC, 0, 4);
 477 }
 478
 479 int mqc_restart_enc(opj_mqc_t *mqc)
 480 {
 481     int correction = 1;
 482
 483     /* <flush part> */
 484     int n = 27 - 15 - mqc->ct;
 485     mqc->c <<= mqc->ct;
 486     while (n > 0) {
 487         mqc_byteout(mqc);
 488         n -= mqc->ct;
 489         mqc->c <<= mqc->ct;
 490     }
 491     mqc_byteout(mqc);
 492
 493     return correction;
 494 }
 495
 496 void mqc_restart_init_enc(opj_mqc_t *mqc)
 497 {
 498     /* <Re-init part> */
 499     mqc_setcurctx(mqc, 0);
 500     mqc->a = 0x8000;
 501     mqc->c = 0;
 502     mqc->ct = 12;
 503     mqc->bp--;
 504     if (*mqc->bp == 0xff) {
 505         mqc->ct = 13;
 506     }
 507 }
 508
 509 void mqc_erterm_enc(opj_mqc_t *mqc)
 510 {
 511     int k = 11 - mqc->ct + 1;
 512
 513     while (k > 0) {
 514         mqc->c <<= mqc->ct;
 515         mqc->ct = 0;
 516         mqc_byteout(mqc);
 517         k -= mqc->ct;
 518     }
 519
 520     if (*mqc->bp != 0xff) {
 521         mqc_byteout(mqc);
 522     }
 523 }
 524
 525 void mqc_segmark_enc(opj_mqc_t *mqc)
 526 {
 527     int i;
 528     mqc_setcurctx(mqc, 18);
 529
 530     for (i = 1; i < 5; i++) {
 531         mqc_encode(mqc, i % 2);
 532     }
 533 }
 534
 535 void mqc_init_dec(opj_mqc_t *mqc, unsigned char *bp, int len)
 536 {
 537     mqc_setcurctx(mqc, 0);
 538     mqc->start = bp;
 539     mqc->end = bp + len;
 540     mqc->bp = bp;
 541     if (len == 0) {
 542         mqc->c = 0xff << 16;
 543     } else {
 544         mqc->c = *mqc->bp << 16;
 545     }
 546     mqc_bytein(mqc);
 547     mqc->c <<= 7;
 548     mqc->ct -= 7;
 549     mqc->a = 0x8000;
 550 }
 551
 552 int mqc_decode(opj_mqc_t *mqc)
 553 {
 554     int d;
 555     mqc->a -= (*mqc->curctx)->qeval;
 556     if ((mqc->c >> 16) < (*mqc->curctx)->qeval) {
 557         d = mqc_lpsexchange(mqc);
 558         mqc_renormd(mqc);
 559     } else {
 560         mqc->c -= (*mqc->curctx)->qeval << 16;
 561         if ((mqc->a & 0x8000) == 0) {
 562             d = mqc_mpsexchange(mqc);
 563             mqc_renormd(mqc);
 564         } else {
 565             d = (*mqc->curctx)->mps;
 566         }
 567     }
 568
 569     return d;
 570 }
 571
 572 void mqc_resetstates(opj_mqc_t *mqc)
 573 {
 574     int i;
 575     for (i = 0; i < MQC_NUMCTXS; i++) {
 576         mqc->ctxs[i] = mqc_states;
 577     }
 578 }
 579
 580 void mqc_setstate(opj_mqc_t *mqc, int ctxno, int msb, int prob)
 581 {
 582     mqc->ctxs[ctxno] = &mqc_states[msb + (prob << 1)];
 583 }
 584
 585