workbench/devs/diskimage/plugins/dmg/adc.c

   1 /* Copyright 2007-2012 Fredrik Wikstrom. All rights reserved.
   2 **
   3 ** Redistribution and use in source and binary forms, with or without
   4 ** modification, are permitted provided that the following conditions
   5 ** are met:
   6 **
   7 ** 1. Redistributions of source code must retain the above copyright
   8 **    notice, this list of conditions and the following disclaimer.
   9 **
  10 ** 2. Redistributions in binary form must reproduce the above copyright
  11 **    notice, this list of conditions and the following disclaimer in the
  12 **    documentation and/or other materials provided with the distribution.
  13 **
  14 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  15 ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17 ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  18 ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  19 ** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  20 ** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  21 ** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  22 ** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  23 ** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  24 ** POSSIBILITY OF SUCH DAMAGE.
  25 */
  26
  27 #include "adc.h"
  28 #include <exec/types.h>
  29 #include <string.h>
  30
  31 LONG adc_decompress(APTR dst, LONG dst_len, APTR src, LONG src_len) {
  32         UBYTE *in = (UBYTE *)src;
  33         UBYTE *out = (UBYTE *)dst;
  34         UBYTE c;
  35         LONG len, off;
  36         LONG bytes_written;
  37
  38         while (dst_len > 0 && src_len > 0) {
  39                 c = *in++;
  40                 src_len--;
  41                 switch (c & 0xc0) {
  42                         case 0x80:
  43                         case 0xc0:
  44                                 len = (c & 0x7f) + 1;
  45                                 if (len > src_len) len = src_len;
  46                                 if (len > dst_len) len = dst_len;
  47                                 memcpy(out, in, len);
  48                                 in += len;
  49                                 out += len;
  50                                 src_len -= len;
  51                                 dst_len -= len;
  52                                 break;
  53                         case 0x00:
  54                                 if (src_len < 1) {
  55                                         src_len = 0;
  56                                         break;
  57                                 }
  58                                 len = ((c & 0x3c) >> 2) + 3;
  59                                 off = (((UWORD)in[0] & 0x03) << 8) + (UWORD)in[1] + 1;
  60                                 bytes_written = out - (UBYTE *)dst;
  61                                 if (len > dst_len) len = dst_len;
  62                                 if (off <= bytes_written) {
  63                                         memset(out, out[-off], len);
  64                                 } else {
  65                                         memset(out, 0, len);
  66                                 }
  67                                 out += len;
  68                                 src_len -= 1;
  69                                 dst_len -= len;
  70                                 break;
  71                         case 0x40:
  72                                 if (src_len < 2) {
  73                                         src_len = 0;
  74                                         break;
  75                                 }
  76                                 len = (c & 0x3f) + 4;
  77                                 off = ((UWORD)in[1] << 8) + (UWORD)in[2];
  78                                 bytes_written = out - (UBYTE *)dst;
  79                                 if (len > dst_len) len = dst_len;
  80                                 if (off <= bytes_written) {
  81                                         memset(out, out[-off], len);
  82                                 } else {
  83                                         memset(out, 0, len);
  84                                 }
  85                                 out += len;
  86                                 src_len -= 2;
  87                                 dst_len -= len;
  88                                 break;
  89                 }
  90         }
  91         if (dst_len > 0) {
  92                 memset(out, 0, dst_len);
  93         }
  94         bytes_written = out - (UBYTE *)dst;
  95         return bytes_written;
  96 }