reactos/lib/rtl/compress.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2002 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /* $Id$
  20  *
  21  * COPYRIGHT:         See COPYING in the top level directory
  22  * PROJECT:           ReactOS kernel
  23  * PURPOSE:           Compression and decompression functions
  24  * FILE:              lib/rtl/compress.c
  25  * PROGRAMER:         Eric Kohl (ekohl@rz-online.de)
  26  */
  27
  28 /* INCLUDES *****************************************************************/
  29
  30 #include <ddk/ntddk.h>
  31
  32 #define NDEBUG
  33 #include <debug.h>
  34
  35
  36 /* MACROS *******************************************************************/
  37
  38 #define COMPRESSION_FORMAT_MASK  0x00FF
  39 #define COMPRESSION_ENGINE_MASK  0xFF00
  40
  41
  42
  43
  44 /* FUNCTIONS ****************************************************************/
  45
  46
  47 static NTSTATUS
  48 RtlpCompressBufferLZNT1(USHORT Engine,
  49                         PUCHAR UncompressedBuffer,
  50                         ULONG UncompressedBufferSize,
  51                         PUCHAR CompressedBuffer,
  52                         ULONG CompressedBufferSize,
  53                         ULONG UncompressedChunkSize,
  54                         PULONG FinalCompressedSize,
  55                         PVOID WorkSpace)
  56 {
  57    return(STATUS_NOT_IMPLEMENTED);
  58 }
  59
  60
  61 static NTSTATUS
  62 RtlpWorkSpaceSizeLZNT1(USHORT Engine,
  63                        PULONG BufferAndWorkSpaceSize,
  64                        PULONG FragmentWorkSpaceSize)
  65 {
  66    if (Engine == COMPRESSION_ENGINE_STANDARD)
  67    {
  68       *BufferAndWorkSpaceSize = 0x8010;
  69       *FragmentWorkSpaceSize = 0x1000;
  70       return(STATUS_SUCCESS);
  71    }
  72    else if (Engine == COMPRESSION_ENGINE_MAXIMUM)
  73    {
  74       *BufferAndWorkSpaceSize = 0x10;
  75       *FragmentWorkSpaceSize = 0x1000;
  76       return(STATUS_SUCCESS);
  77    }
  78
  79    return(STATUS_NOT_SUPPORTED);
  80 }
  81
  82
  83 /*
  84  * @implemented
  85  */
  86 NTSTATUS STDCALL
  87 RtlCompressBuffer(IN USHORT CompressionFormatAndEngine,
  88                   IN PUCHAR UncompressedBuffer,
  89                   IN ULONG UncompressedBufferSize,
  90                   OUT PUCHAR CompressedBuffer,
  91                   IN ULONG CompressedBufferSize,
  92                   IN ULONG UncompressedChunkSize,
  93                   OUT PULONG FinalCompressedSize,
  94                   IN PVOID WorkSpace)
  95 {
  96    USHORT Format = CompressionFormatAndEngine & COMPRESSION_FORMAT_MASK;
  97    USHORT Engine = CompressionFormatAndEngine & COMPRESSION_ENGINE_MASK;
  98
  99    if ((Format == COMPRESSION_FORMAT_NONE) ||
 100          (Format == COMPRESSION_FORMAT_DEFAULT))
 101       return(STATUS_INVALID_PARAMETER);
 102
 103    if (Format == COMPRESSION_FORMAT_LZNT1)
 104       return(RtlpCompressBufferLZNT1(Engine,
 105                                      UncompressedBuffer,
 106                                      UncompressedBufferSize,
 107                                      CompressedBuffer,
 108                                      CompressedBufferSize,
 109                                      UncompressedChunkSize,
 110                                      FinalCompressedSize,
 111                                      WorkSpace));
 112
 113    return(STATUS_UNSUPPORTED_COMPRESSION);
 114 }
 115
 116
 117 /*
 118  * @unimplemented
 119  */
 120 NTSTATUS STDCALL
 121 RtlCompressChunks(IN PUCHAR UncompressedBuffer,
 122                   IN ULONG UncompressedBufferSize,
 123                   OUT PUCHAR CompressedBuffer,
 124                   IN ULONG CompressedBufferSize,
 125                   IN OUT PCOMPRESSED_DATA_INFO CompressedDataInfo,
 126                   IN ULONG CompressedDataInfoLength,
 127                   IN PVOID WorkSpace)
 128 {
 129    return(STATUS_NOT_IMPLEMENTED);
 130 }
 131
 132
 133 /*
 134  * @unimplemented
 135  */
 136 NTSTATUS STDCALL
 137 RtlDecompressBuffer(IN USHORT CompressionFormat,
 138                     OUT PUCHAR UncompressedBuffer,
 139                     IN ULONG UncompressedBufferSize,
 140                     IN PUCHAR CompressedBuffer,
 141                     IN ULONG CompressedBufferSize,
 142                     OUT PULONG FinalUncompressedSize)
 143 {
 144    return(STATUS_NOT_IMPLEMENTED);
 145 }
 146
 147
 148 /*
 149  * @unimplemented
 150  */
 151 NTSTATUS STDCALL
 152 RtlDecompressChunks(OUT PUCHAR UncompressedBuffer,
 153                     IN ULONG UncompressedBufferSize,
 154                     IN PUCHAR CompressedBuffer,
 155                     IN ULONG CompressedBufferSize,
 156                     IN PUCHAR CompressedTail,
 157                     IN ULONG CompressedTailSize,
 158                     IN PCOMPRESSED_DATA_INFO CompressedDataInfo)
 159 {
 160    return(STATUS_NOT_IMPLEMENTED);
 161 }
 162
 163
 164 /*
 165  * @unimplemented
 166  */
 167 NTSTATUS STDCALL
 168 RtlDecompressFragment(IN USHORT CompressionFormat,
 169                       OUT PUCHAR UncompressedFragment,
 170                       IN ULONG UncompressedFragmentSize,
 171                       IN PUCHAR CompressedBuffer,
 172                       IN ULONG CompressedBufferSize,
 173                       IN ULONG FragmentOffset,
 174                       OUT PULONG FinalUncompressedSize,
 175                       IN PVOID WorkSpace)
 176 {
 177    return(STATUS_NOT_IMPLEMENTED);
 178 }
 179
 180
 181 /*
 182  * @unimplemented
 183  */
 184 NTSTATUS STDCALL
 185 RtlDescribeChunk(IN USHORT CompressionFormat,
 186                  IN OUT PUCHAR *CompressedBuffer,
 187                  IN PUCHAR EndOfCompressedBufferPlus1,
 188                  OUT PUCHAR *ChunkBuffer,
 189                  OUT PULONG ChunkSize)
 190 {
 191    return(STATUS_NOT_IMPLEMENTED);
 192 }
 193
 194
 195 /*
 196  * @unimplemented
 197  */
 198 NTSTATUS STDCALL
 199 RtlGetCompressionWorkSpaceSize(IN USHORT CompressionFormatAndEngine,
 200                                OUT PULONG CompressBufferAndWorkSpaceSize,
 201                                OUT PULONG CompressFragmentWorkSpaceSize)
 202 {
 203    USHORT Format = CompressionFormatAndEngine & COMPRESSION_FORMAT_MASK;
 204    USHORT Engine = CompressionFormatAndEngine & COMPRESSION_ENGINE_MASK;
 205
 206    if ((Format == COMPRESSION_FORMAT_NONE) ||
 207          (Format == COMPRESSION_FORMAT_DEFAULT))
 208       return(STATUS_INVALID_PARAMETER);
 209
 210    if (Format == COMPRESSION_FORMAT_LZNT1)
 211       return(RtlpWorkSpaceSizeLZNT1(Engine,
 212                                     CompressBufferAndWorkSpaceSize,
 213                                     CompressFragmentWorkSpaceSize));
 214
 215    return(STATUS_UNSUPPORTED_COMPRESSION);
 216 }
 217
 218
 219
 220 /*
 221  * @unimplemented
 222  */
 223 NTSTATUS STDCALL
 224 RtlReserveChunk(IN USHORT CompressionFormat,
 225                 IN OUT PUCHAR *CompressedBuffer,
 226                 IN PUCHAR EndOfCompressedBufferPlus1,
 227                 OUT PUCHAR *ChunkBuffer,
 228                 IN ULONG ChunkSize)
 229 {
 230    return(STATUS_NOT_IMPLEMENTED);
 231 }
 232
 233 /* EOF */