src/png/pngmem.c

   1
   2 /* pngmem.c - stub functions for memory allocation
   3  *
   4  * Last changed in libpng 1.5.7 [December 15, 2011]
   5  * Copyright (c) 1998-2011 Glenn Randers-Pehrson
   6  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
   7  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
   8  *
   9  * This code is released under the libpng license.
  10  * For conditions of distribution and use, see the disclaimer
  11  * and license in png.h
  12  *
  13  * This file provides a location for all memory allocation.  Users who
  14  * need special memory handling are expected to supply replacement
  15  * functions for png_malloc() and png_free(), and to use
  16  * png_create_read_struct_2() and png_create_write_struct_2() to
  17  * identify the replacement functions.
  18  */
  19
  20 #include "pngpriv.h"
  21
  22 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  23
  24 /* Borland DOS special memory handler */
  25 #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
  26 /* If you change this, be sure to change the one in png.h also */
  27
  28 /* Allocate memory for a png_struct.  The malloc and memset can be replaced
  29    by a single call to calloc() if this is thought to improve performance. */
  30 PNG_FUNCTION(png_voidp /* PRIVATE */,
  31 png_create_struct,(int type),PNG_ALLOCATED)
  32 {
  33 #  ifdef PNG_USER_MEM_SUPPORTED
  34    return (png_create_struct_2(type, NULL, NULL));
  35 }
  36
  37 /* Alternate version of png_create_struct, for use with user-defined malloc. */
  38 PNG_FUNCTION(png_voidp /* PRIVATE */,
  39 png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr),
  40    PNG_ALLOCATED)
  41 {
  42 #  endif /* PNG_USER_MEM_SUPPORTED */
  43    png_size_t size;
  44    png_voidp struct_ptr;
  45
  46    if (type == PNG_STRUCT_INFO)
  47       size = png_sizeof(png_info);
  48
  49    else if (type == PNG_STRUCT_PNG)
  50       size = png_sizeof(png_struct);
  51
  52    else
  53       return (png_get_copyright(NULL));
  54
  55 #  ifdef PNG_USER_MEM_SUPPORTED
  56    if (malloc_fn != NULL)
  57    {
  58       png_struct dummy_struct;
  59       memset(&dummy_struct, 0, sizeof dummy_struct);
  60       dummy_struct.mem_ptr=mem_ptr;
  61       struct_ptr = (*(malloc_fn))(&dummy_struct, (png_alloc_size_t)size);
  62    }
  63
  64    else
  65 #  endif /* PNG_USER_MEM_SUPPORTED */
  66    struct_ptr = (png_voidp)farmalloc(size);
  67    if (struct_ptr != NULL)
  68       png_memset(struct_ptr, 0, size);
  69
  70    return (struct_ptr);
  71 }
  72
  73 /* Free memory allocated by a png_create_struct() call */
  74 void /* PRIVATE */
  75 png_destroy_struct(png_voidp struct_ptr)
  76 {
  77 #  ifdef PNG_USER_MEM_SUPPORTED
  78    png_destroy_struct_2(struct_ptr, NULL, NULL);
  79 }
  80
  81 /* Free memory allocated by a png_create_struct() call */
  82 void /* PRIVATE */
  83 png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
  84     png_voidp mem_ptr)
  85 {
  86 #  endif
  87    if (struct_ptr != NULL)
  88    {
  89 #  ifdef PNG_USER_MEM_SUPPORTED
  90       if (free_fn != NULL)
  91       {
  92          png_struct dummy_struct;
  93          memset(&dummy_struct, 0, sizeof dummy_struct);
  94          dummy_struct.mem_ptr=mem_ptr;
  95          (*(free_fn))(&dummy_struct, struct_ptr);
  96          return;
  97       }
  98
  99 #  endif /* PNG_USER_MEM_SUPPORTED */
 100       farfree (struct_ptr);
 101    }
 102 }
 103
 104 /* Allocate memory.  For reasonable files, size should never exceed
 105  * 64K.  However, zlib may allocate more then 64K if you don't tell
 106  * it not to.  See zconf.h and png.h for more information. zlib does
 107  * need to allocate exactly 64K, so whatever you call here must
 108  * have the ability to do that.
 109  *
 110  * Borland seems to have a problem in DOS mode for exactly 64K.
 111  * It gives you a segment with an offset of 8 (perhaps to store its
 112  * memory stuff).  zlib doesn't like this at all, so we have to
 113  * detect and deal with it.  This code should not be needed in
 114  * Windows or OS/2 modes, and only in 16 bit mode.  This code has
 115  * been updated by Alexander Lehmann for version 0.89 to waste less
 116  * memory.
 117  *
 118  * Note that we can't use png_size_t for the "size" declaration,
 119  * since on some systems a png_size_t is a 16-bit quantity, and as a
 120  * result, we would be truncating potentially larger memory requests
 121  * (which should cause a fatal error) and introducing major problems.
 122  */
 123 PNG_FUNCTION(png_voidp,PNGAPI
 124 png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
 125 {
 126    png_voidp ret;
 127
 128    ret = (png_malloc(png_ptr, size));
 129
 130    if (ret != NULL)
 131       png_memset(ret,0,(png_size_t)size);
 132
 133    return (ret);
 134 }
 135
 136 PNG_FUNCTION(png_voidp,PNGAPI
 137 png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
 138 {
 139    png_voidp ret;
 140
 141    if (png_ptr == NULL || size == 0)
 142       return (NULL);
 143
 144 #  ifdef PNG_USER_MEM_SUPPORTED
 145    if (png_ptr->malloc_fn != NULL)
 146       ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, size));
 147
 148    else
 149       ret = (png_malloc_default(png_ptr, size));
 150
 151    if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 152        png_error(png_ptr, "Out of memory");
 153
 154    return (ret);
 155 }
 156
 157 PNG_FUNCTION(png_voidp,PNGAPI
 158 png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
 159 {
 160    png_voidp ret;
 161 #  endif /* PNG_USER_MEM_SUPPORTED */
 162
 163    if (png_ptr == NULL || size == 0)
 164       return (NULL);
 165
 166 #  ifdef PNG_MAX_MALLOC_64K
 167    if (size > (png_uint_32)65536L)
 168    {
 169       png_warning(png_ptr, "Cannot Allocate > 64K");
 170       ret = NULL;
 171    }
 172
 173    else
 174 #  endif
 175
 176    if (size != (size_t)size)
 177       ret = NULL;
 178
 179    else if (size == (png_uint_32)65536L)
 180    {
 181       if (png_ptr->offset_table == NULL)
 182       {
 183          /* Try to see if we need to do any of this fancy stuff */
 184          ret = farmalloc(size);
 185          if (ret == NULL || ((png_size_t)ret & 0xffff))
 186          {
 187             int num_blocks;
 188             png_uint_32 total_size;
 189             png_bytep table;
 190             int i, mem_level, window_bits;
 191             png_byte huge * hptr;
 192             int window_bits
 193
 194             if (ret != NULL)
 195             {
 196                farfree(ret);
 197                ret = NULL;
 198             }
 199
 200             window_bits =
 201                 png_ptr->zlib_window_bits >= png_ptr->zlib_text_window_bits ?
 202                 png_ptr->zlib_window_bits : png_ptr->zlib_text_window_bits;
 203
 204             if (window_bits > 14)
 205                num_blocks = (int)(1 << (window_bits - 14));
 206
 207             else
 208                num_blocks = 1;
 209
 210             mem_level =
 211                 png_ptr->zlib_mem_level >= png_ptr->zlib_text_mem_level ?
 212                 png_ptr->zlib_mem_level : png_ptr->zlib_text_mem_level;
 213
 214             if (mem_level >= 7)
 215                num_blocks += (int)(1 << (mem_level - 7));
 216
 217             else
 218                num_blocks++;
 219
 220             total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;
 221
 222             table = farmalloc(total_size);
 223
 224             if (table == NULL)
 225             {
 226 #  ifndef PNG_USER_MEM_SUPPORTED
 227                if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 228                   png_error(png_ptr, "Out Of Memory"); /* Note "O", "M" */
 229
 230                else
 231                   png_warning(png_ptr, "Out Of Memory");
 232 #  endif
 233                return (NULL);
 234             }
 235
 236             if ((png_size_t)table & 0xfff0)
 237             {
 238 #  ifndef PNG_USER_MEM_SUPPORTED
 239                if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 240                   png_error(png_ptr,
 241                     "Farmalloc didn't return normalized pointer");
 242
 243                else
 244                   png_warning(png_ptr,
 245                     "Farmalloc didn't return normalized pointer");
 246 #  endif
 247                return (NULL);
 248             }
 249
 250             png_ptr->offset_table = table;
 251             png_ptr->offset_table_ptr = farmalloc(num_blocks *
 252                png_sizeof(png_bytep));
 253
 254             if (png_ptr->offset_table_ptr == NULL)
 255             {
 256 #  ifndef PNG_USER_MEM_SUPPORTED
 257                if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 258                   png_error(png_ptr, "Out Of memory"); /* Note "O", "m" */
 259
 260                else
 261                   png_warning(png_ptr, "Out Of memory");
 262 #  endif
 263                return (NULL);
 264             }
 265
 266             hptr = (png_byte huge *)table;
 267             if ((png_size_t)hptr & 0xf)
 268             {
 269                hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
 270                hptr = hptr + 16L;  /* "hptr += 16L" fails on Turbo C++ 3.0 */
 271             }
 272
 273             for (i = 0; i < num_blocks; i++)
 274             {
 275                png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
 276                hptr = hptr + (png_uint_32)65536L;  /* "+=" fails on TC++3.0 */
 277             }
 278
 279             png_ptr->offset_table_number = num_blocks;
 280             png_ptr->offset_table_count = 0;
 281             png_ptr->offset_table_count_free = 0;
 282          }
 283       }
 284
 285       if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
 286       {
 287 #  ifndef PNG_USER_MEM_SUPPORTED
 288          if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 289             png_error(png_ptr, "Out of Memory"); /* Note "O" and "M" */
 290
 291          else
 292             png_warning(png_ptr, "Out of Memory");
 293 #  endif
 294          return (NULL);
 295       }
 296
 297       ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
 298    }
 299
 300    else
 301       ret = farmalloc(size);
 302
 303 #  ifndef PNG_USER_MEM_SUPPORTED
 304    if (ret == NULL)
 305    {
 306       if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 307          png_error(png_ptr, "Out of memory"); /* Note "o" and "m" */
 308
 309       else
 310          png_warning(png_ptr, "Out of memory"); /* Note "o" and "m" */
 311    }
 312 #  endif
 313
 314    return (ret);
 315 }
 316
 317 /* Free a pointer allocated by png_malloc().  In the default
 318  * configuration, png_ptr is not used, but is passed in case it
 319  * is needed.  If ptr is NULL, return without taking any action.
 320  */
 321 void PNGAPI
 322 png_free(png_structp png_ptr, png_voidp ptr)
 323 {
 324    if (png_ptr == NULL || ptr == NULL)
 325       return;
 326
 327 #  ifdef PNG_USER_MEM_SUPPORTED
 328    if (png_ptr->free_fn != NULL)
 329    {
 330       (*(png_ptr->free_fn))(png_ptr, ptr);
 331       return;
 332    }
 333
 334    else
 335       png_free_default(png_ptr, ptr);
 336 }
 337
 338 void PNGAPI
 339 png_free_default(png_structp png_ptr, png_voidp ptr)
 340 {
 341 #  endif /* PNG_USER_MEM_SUPPORTED */
 342
 343    if (png_ptr == NULL || ptr == NULL)
 344       return;
 345
 346    if (png_ptr->offset_table != NULL)
 347    {
 348       int i;
 349
 350       for (i = 0; i < png_ptr->offset_table_count; i++)
 351       {
 352          if (ptr == png_ptr->offset_table_ptr[i])
 353          {
 354             ptr = NULL;
 355             png_ptr->offset_table_count_free++;
 356             break;
 357          }
 358       }
 359       if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)
 360       {
 361          farfree(png_ptr->offset_table);
 362          farfree(png_ptr->offset_table_ptr);
 363          png_ptr->offset_table = NULL;
 364          png_ptr->offset_table_ptr = NULL;
 365       }
 366    }
 367
 368    if (ptr != NULL)
 369       farfree(ptr);
 370 }
 371
 372 #else /* Not the Borland DOS special memory handler */
 373
 374 /* Allocate memory for a png_struct or a png_info.  The malloc and
 375    memset can be replaced by a single call to calloc() if this is thought
 376    to improve performance noticably. */
 377 PNG_FUNCTION(png_voidp /* PRIVATE */,
 378 png_create_struct,(int type),PNG_ALLOCATED)
 379 {
 380 #  ifdef PNG_USER_MEM_SUPPORTED
 381    return (png_create_struct_2(type, NULL, NULL));
 382 }
 383
 384 /* Allocate memory for a png_struct or a png_info.  The malloc and
 385    memset can be replaced by a single call to calloc() if this is thought
 386    to improve performance noticably. */
 387 PNG_FUNCTION(png_voidp /* PRIVATE */,
 388 png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr),
 389    PNG_ALLOCATED)
 390 {
 391 #  endif /* PNG_USER_MEM_SUPPORTED */
 392    png_size_t size;
 393    png_voidp struct_ptr;
 394
 395    if (type == PNG_STRUCT_INFO)
 396       size = png_sizeof(png_info);
 397
 398    else if (type == PNG_STRUCT_PNG)
 399       size = png_sizeof(png_struct);
 400
 401    else
 402       return (NULL);
 403
 404 #  ifdef PNG_USER_MEM_SUPPORTED
 405    if (malloc_fn != NULL)
 406    {
 407       png_struct dummy_struct;
 408       png_structp png_ptr = &dummy_struct;
 409       png_ptr->mem_ptr=mem_ptr;
 410       struct_ptr = (*(malloc_fn))(png_ptr, size);
 411
 412       if (struct_ptr != NULL)
 413          png_memset(struct_ptr, 0, size);
 414
 415       return (struct_ptr);
 416    }
 417 #  endif /* PNG_USER_MEM_SUPPORTED */
 418
 419 #  if defined(__TURBOC__) && !defined(__FLAT__)
 420    struct_ptr = (png_voidp)farmalloc(size);
 421 #  else
 422 #    if defined(_MSC_VER) && defined(MAXSEG_64K)
 423    struct_ptr = (png_voidp)halloc(size, 1);
 424 #    else
 425    struct_ptr = (png_voidp)malloc(size);
 426 #    endif
 427 #  endif
 428
 429    if (struct_ptr != NULL)
 430       png_memset(struct_ptr, 0, size);
 431
 432    return (struct_ptr);
 433 }
 434
 435
 436 /* Free memory allocated by a png_create_struct() call */
 437 void /* PRIVATE */
 438 png_destroy_struct(png_voidp struct_ptr)
 439 {
 440 #  ifdef PNG_USER_MEM_SUPPORTED
 441    png_destroy_struct_2(struct_ptr, NULL, NULL);
 442 }
 443
 444 /* Free memory allocated by a png_create_struct() call */
 445 void /* PRIVATE */
 446 png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
 447     png_voidp mem_ptr)
 448 {
 449 #  endif /* PNG_USER_MEM_SUPPORTED */
 450    if (struct_ptr != NULL)
 451    {
 452 #  ifdef PNG_USER_MEM_SUPPORTED
 453       if (free_fn != NULL)
 454       {
 455          png_struct dummy_struct;
 456          png_structp png_ptr = &dummy_struct;
 457          png_ptr->mem_ptr=mem_ptr;
 458          (*(free_fn))(png_ptr, struct_ptr);
 459          return;
 460       }
 461 #  endif /* PNG_USER_MEM_SUPPORTED */
 462 #  if defined(__TURBOC__) && !defined(__FLAT__)
 463       farfree(struct_ptr);
 464
 465 #  else
 466 #    if defined(_MSC_VER) && defined(MAXSEG_64K)
 467       hfree(struct_ptr);
 468
 469 #    else
 470       free(struct_ptr);
 471
 472 #    endif
 473 #  endif
 474    }
 475 }
 476
 477 /* Allocate memory.  For reasonable files, size should never exceed
 478  * 64K.  However, zlib may allocate more then 64K if you don't tell
 479  * it not to.  See zconf.h and png.h for more information.  zlib does
 480  * need to allocate exactly 64K, so whatever you call here must
 481  * have the ability to do that.
 482  */
 483
 484 PNG_FUNCTION(png_voidp,PNGAPI
 485 png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
 486 {
 487    png_voidp ret;
 488
 489    ret = (png_malloc(png_ptr, size));
 490
 491    if (ret != NULL)
 492       png_memset(ret,0,(png_size_t)size);
 493
 494    return (ret);
 495 }
 496
 497 PNG_FUNCTION(png_voidp,PNGAPI
 498 png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
 499 {
 500    png_voidp ret;
 501
 502 #  ifdef PNG_USER_MEM_SUPPORTED
 503    if (png_ptr == NULL || size == 0)
 504       return (NULL);
 505
 506    if (png_ptr->malloc_fn != NULL)
 507       ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
 508
 509    else
 510       ret = (png_malloc_default(png_ptr, size));
 511
 512    if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 513        png_error(png_ptr, "Out of Memory");
 514
 515    return (ret);
 516 }
 517
 518 PNG_FUNCTION(png_voidp,PNGAPI
 519 png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
 520 {
 521    png_voidp ret;
 522 #  endif /* PNG_USER_MEM_SUPPORTED */
 523
 524    if (png_ptr == NULL || size == 0)
 525       return (NULL);
 526
 527 #  ifdef PNG_MAX_MALLOC_64K
 528    if (size > (png_uint_32)65536L)
 529    {
 530 #    ifndef PNG_USER_MEM_SUPPORTED
 531       if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 532          png_error(png_ptr, "Cannot Allocate > 64K");
 533
 534       else
 535 #    endif
 536          return NULL;
 537    }
 538 #  endif
 539
 540    /* Check for overflow */
 541 #  if defined(__TURBOC__) && !defined(__FLAT__)
 542
 543    if (size != (unsigned long)size)
 544       ret = NULL;
 545
 546    else
 547       ret = farmalloc(size);
 548
 549 #  else
 550 #    if defined(_MSC_VER) && defined(MAXSEG_64K)
 551    if (size != (unsigned long)size)
 552       ret = NULL;
 553
 554    else
 555       ret = halloc(size, 1);
 556
 557 #    else
 558    if (size != (size_t)size)
 559       ret = NULL;
 560
 561    else
 562       ret = malloc((size_t)size);
 563 #    endif
 564 #  endif
 565
 566 #  ifndef PNG_USER_MEM_SUPPORTED
 567    if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 568       png_error(png_ptr, "Out of Memory");
 569 #  endif
 570
 571    return (ret);
 572 }
 573
 574 /* Free a pointer allocated by png_malloc().  If ptr is NULL, return
 575  * without taking any action.
 576  */
 577 void PNGAPI
 578 png_free(png_structp png_ptr, png_voidp ptr)
 579 {
 580    if (png_ptr == NULL || ptr == NULL)
 581       return;
 582
 583 #  ifdef PNG_USER_MEM_SUPPORTED
 584    if (png_ptr->free_fn != NULL)
 585    {
 586       (*(png_ptr->free_fn))(png_ptr, ptr);
 587       return;
 588    }
 589
 590    else
 591       png_free_default(png_ptr, ptr);
 592 }
 593
 594 void PNGAPI
 595 png_free_default(png_structp png_ptr, png_voidp ptr)
 596 {
 597    if (png_ptr == NULL || ptr == NULL)
 598       return;
 599
 600 #  endif /* PNG_USER_MEM_SUPPORTED */
 601
 602 #  if defined(__TURBOC__) && !defined(__FLAT__)
 603    farfree(ptr);
 604
 605 #  else
 606 #    if defined(_MSC_VER) && defined(MAXSEG_64K)
 607    hfree(ptr);
 608
 609 #    else
 610    free(ptr);
 611
 612 #    endif
 613 #  endif
 614 }
 615 #endif /* Not Borland DOS special memory handler */
 616
 617 /* This function was added at libpng version 1.2.3.  The png_malloc_warn()
 618  * function will set up png_malloc() to issue a png_warning and return NULL
 619  * instead of issuing a png_error, if it fails to allocate the requested
 620  * memory.
 621  */
 622 PNG_FUNCTION(png_voidp,PNGAPI
 623 png_malloc_warn,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
 624 {
 625    png_voidp ptr;
 626    png_uint_32 save_flags;
 627    if (png_ptr == NULL)
 628       return (NULL);
 629
 630    save_flags = png_ptr->flags;
 631    png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
 632    ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);
 633    png_ptr->flags=save_flags;
 634    return(ptr);
 635 }
 636
 637
 638 #ifdef PNG_USER_MEM_SUPPORTED
 639 /* This function is called when the application wants to use another method
 640  * of allocating and freeing memory.
 641  */
 642 void PNGAPI
 643 png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
 644   malloc_fn, png_free_ptr free_fn)
 645 {
 646    if (png_ptr != NULL)
 647    {
 648       png_ptr->mem_ptr = mem_ptr;
 649       png_ptr->malloc_fn = malloc_fn;
 650       png_ptr->free_fn = free_fn;
 651    }
 652 }
 653
 654 /* This function returns a pointer to the mem_ptr associated with the user
 655  * functions.  The application should free any memory associated with this
 656  * pointer before png_write_destroy and png_read_destroy are called.
 657  */
 658 png_voidp PNGAPI
 659 png_get_mem_ptr(png_const_structp png_ptr)
 660 {
 661    if (png_ptr == NULL)
 662       return (NULL);
 663
 664    return ((png_voidp)png_ptr->mem_ptr);
 665 }
 666 #endif /* PNG_USER_MEM_SUPPORTED */
 667 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */