• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2018 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "xz_utils.h"
18 
19 #include <vector>
20 #include <mutex>
21 
22 #include "base/array_ref.h"
23 #include "base/bit_utils.h"
24 #include "base/leb128.h"
25 #include "dwarf/writer.h"
26 
27 // liblzma.
28 #include "7zCrc.h"
29 #include "Xz.h"
30 #include "XzCrc64.h"
31 #include "XzEnc.h"
32 
33 namespace art {
34 
XzInitCrc()35 static void XzInitCrc() {
36   static std::once_flag crc_initialized;
37   std::call_once(crc_initialized, []() {
38     CrcGenerateTable();
39     Crc64GenerateTable();
40   });
41 }
42 
XzCompress(ArrayRef<const uint8_t> src,std::vector<uint8_t> * dst,int level,size_t block_size)43 void XzCompress(ArrayRef<const uint8_t> src,
44                 std::vector<uint8_t>* dst,
45                 int level,
46                 size_t block_size) {
47   // Configure the compression library.
48   XzInitCrc();
49   CLzma2EncProps lzma2Props;
50   Lzma2EncProps_Init(&lzma2Props);
51   lzma2Props.lzmaProps.level = level;
52   lzma2Props.lzmaProps.reduceSize = src.size();  // Size of data that will be compressed.
53   lzma2Props.blockSize = block_size;
54   Lzma2EncProps_Normalize(&lzma2Props);
55   CXzProps props;
56   XzProps_Init(&props);
57   props.lzma2Props = lzma2Props;
58   // Implement the required interface for communication (written in C so no virtual methods).
59   struct XzCallbacks : public ISeqInStream, public ISeqOutStream, public ICompressProgress {
60     static SRes ReadImpl(const ISeqInStream* p, void* buf, size_t* size) {
61       auto* ctx = static_cast<XzCallbacks*>(const_cast<ISeqInStream*>(p));
62       *size = std::min(*size, ctx->src_.size() - ctx->src_pos_);
63       memcpy(buf, ctx->src_.data() + ctx->src_pos_, *size);
64       ctx->src_pos_ += *size;
65       return SZ_OK;
66     }
67     static size_t WriteImpl(const ISeqOutStream* p, const void* buf, size_t size) {
68       auto* ctx = static_cast<const XzCallbacks*>(p);
69       const uint8_t* buffer = reinterpret_cast<const uint8_t*>(buf);
70       ctx->dst_->insert(ctx->dst_->end(), buffer, buffer + size);
71       return size;
72     }
73     static SRes ProgressImpl(const ICompressProgress* , UInt64, UInt64) {
74       return SZ_OK;
75     }
76     size_t src_pos_;
77     ArrayRef<const uint8_t> src_;
78     std::vector<uint8_t>* dst_;
79   };
80   XzCallbacks callbacks;
81   callbacks.Read = XzCallbacks::ReadImpl;
82   callbacks.Write = XzCallbacks::WriteImpl;
83   callbacks.Progress = XzCallbacks::ProgressImpl;
84   callbacks.src_pos_ = 0;
85   callbacks.src_ = src;
86   callbacks.dst_ = dst;
87   // Compress.
88   SRes res = Xz_Encode(&callbacks, &callbacks, &props, &callbacks);
89   CHECK_EQ(res, SZ_OK);
90 
91   // Decompress the data back and check that we get the original.
92   if (kIsDebugBuild) {
93     std::vector<uint8_t> decompressed;
94     XzDecompress(ArrayRef<const uint8_t>(*dst), &decompressed);
95     DCHECK_EQ(decompressed.size(), src.size());
96     DCHECK_EQ(memcmp(decompressed.data(), src.data(), src.size()), 0);
97   }
98 }
99 
XzDecompress(ArrayRef<const uint8_t> src,std::vector<uint8_t> * dst)100 void XzDecompress(ArrayRef<const uint8_t> src, std::vector<uint8_t>* dst) {
101   XzInitCrc();
102   std::unique_ptr<CXzUnpacker> state(new CXzUnpacker());
103   ISzAlloc alloc;
104   alloc.Alloc = [](ISzAllocPtr, size_t size) { return malloc(size); };
105   alloc.Free = [](ISzAllocPtr, void* ptr) { return free(ptr); };
106   XzUnpacker_Construct(state.get(), &alloc);
107 
108   size_t src_offset = 0;
109   size_t dst_offset = 0;
110   ECoderStatus status;
111   do {
112     dst->resize(RoundUp(dst_offset + kPageSize / 4, kPageSize));
113     size_t src_remaining = src.size() - src_offset;
114     size_t dst_remaining = dst->size() - dst_offset;
115     int return_val = XzUnpacker_Code(state.get(),
116                                      dst->data() + dst_offset,
117                                      &dst_remaining,
118                                      src.data() + src_offset,
119                                      &src_remaining,
120                                      true,
121                                      CODER_FINISH_ANY,
122                                      &status);
123     CHECK_EQ(return_val, SZ_OK);
124     src_offset += src_remaining;
125     dst_offset += dst_remaining;
126   } while (status == CODER_STATUS_NOT_FINISHED);
127   CHECK_EQ(src_offset, src.size());
128   CHECK(XzUnpacker_IsStreamWasFinished(state.get()));
129   XzUnpacker_Free(state.get());
130   dst->resize(dst_offset);
131 }
132 
133 }  // namespace art
134