1 // Copyright 2011 Google Inc. All Rights Reserved. 2 // 3 // Use of this source code is governed by a BSD-style license 4 // that can be found in the COPYING file in the root of the source 5 // tree. An additional intellectual property rights grant can be found 6 // in the file PATENTS. All contributing project authors may 7 // be found in the AUTHORS file in the root of the source tree. 8 // ----------------------------------------------------------------------------- 9 // 10 // Alpha-plane decompression. 11 // 12 // Author: Skal (pascal.massimino (at) gmail.com) 13 14 #include <stdlib.h> 15 #include "./alphai.h" 16 #include "./vp8i.h" 17 #include "./vp8li.h" 18 #include "../utils/quant_levels_dec.h" 19 #include "../utils/utils.h" 20 #include "webp/format_constants.h" 21 22 //------------------------------------------------------------------------------ 23 // ALPHDecoder object. 24 25 ALPHDecoder* ALPHNew(void) { 26 ALPHDecoder* const dec = (ALPHDecoder*)WebPSafeCalloc(1ULL, sizeof(*dec)); 27 return dec; 28 } 29 30 void ALPHDelete(ALPHDecoder* const dec) { 31 if (dec != NULL) { 32 VP8LDelete(dec->vp8l_dec_); 33 dec->vp8l_dec_ = NULL; 34 WebPSafeFree(dec); 35 } 36 } 37 38 //------------------------------------------------------------------------------ 39 // Decoding. 40 41 // Initialize alpha decoding by parsing the alpha header and decoding the image 42 // header for alpha data stored using lossless compression. 43 // Returns false in case of error in alpha header (data too short, invalid 44 // compression method or filter, error in lossless header data etc). 45 static int ALPHInit(ALPHDecoder* const dec, const uint8_t* data, 46 size_t data_size, int width, int height, uint8_t* output) { 47 int ok = 0; 48 const uint8_t* const alpha_data = data + ALPHA_HEADER_LEN; 49 const size_t alpha_data_size = data_size - ALPHA_HEADER_LEN; 50 int rsrv; 51 52 assert(width > 0 && height > 0); 53 assert(data != NULL && output != NULL); 54 55 dec->width_ = width; 56 dec->height_ = height; 57 58 if (data_size <= ALPHA_HEADER_LEN) { 59 return 0; 60 } 61 62 dec->method_ = (data[0] >> 0) & 0x03; 63 dec->filter_ = (data[0] >> 2) & 0x03; 64 dec->pre_processing_ = (data[0] >> 4) & 0x03; 65 rsrv = (data[0] >> 6) & 0x03; 66 if (dec->method_ < ALPHA_NO_COMPRESSION || 67 dec->method_ > ALPHA_LOSSLESS_COMPRESSION || 68 dec->filter_ >= WEBP_FILTER_LAST || 69 dec->pre_processing_ > ALPHA_PREPROCESSED_LEVELS || 70 rsrv != 0) { 71 return 0; 72 } 73 74 if (dec->method_ == ALPHA_NO_COMPRESSION) { 75 const size_t alpha_decoded_size = dec->width_ * dec->height_; 76 ok = (alpha_data_size >= alpha_decoded_size); 77 } else { 78 assert(dec->method_ == ALPHA_LOSSLESS_COMPRESSION); 79 ok = VP8LDecodeAlphaHeader(dec, alpha_data, alpha_data_size, output); 80 } 81 return ok; 82 } 83 84 // Decodes, unfilters and dequantizes *at least* 'num_rows' rows of alpha 85 // starting from row number 'row'. It assumes that rows up to (row - 1) have 86 // already been decoded. 87 // Returns false in case of bitstream error. 88 static int ALPHDecode(VP8Decoder* const dec, int row, int num_rows) { 89 ALPHDecoder* const alph_dec = dec->alph_dec_; 90 const int width = alph_dec->width_; 91 const int height = alph_dec->height_; 92 WebPUnfilterFunc unfilter_func = WebPUnfilters[alph_dec->filter_]; 93 uint8_t* const output = dec->alpha_plane_; 94 if (alph_dec->method_ == ALPHA_NO_COMPRESSION) { 95 const size_t offset = row * width; 96 const size_t num_pixels = num_rows * width; 97 assert(dec->alpha_data_size_ >= ALPHA_HEADER_LEN + offset + num_pixels); 98 memcpy(dec->alpha_plane_ + offset, 99 dec->alpha_data_ + ALPHA_HEADER_LEN + offset, num_pixels); 100 } else { // alph_dec->method_ == ALPHA_LOSSLESS_COMPRESSION 101 assert(alph_dec->vp8l_dec_ != NULL); 102 if (!VP8LDecodeAlphaImageStream(alph_dec, row + num_rows)) { 103 return 0; 104 } 105 } 106 107 if (unfilter_func != NULL) { 108 unfilter_func(width, height, width, row, num_rows, output); 109 } 110 111 if (row + num_rows == dec->pic_hdr_.height_) { 112 dec->is_alpha_decoded_ = 1; 113 } 114 return 1; 115 } 116 117 //------------------------------------------------------------------------------ 118 // Main entry point. 119 120 const uint8_t* VP8DecompressAlphaRows(VP8Decoder* const dec, 121 int row, int num_rows) { 122 const int width = dec->pic_hdr_.width_; 123 const int height = dec->pic_hdr_.height_; 124 125 if (row < 0 || num_rows <= 0 || row + num_rows > height) { 126 return NULL; // sanity check. 127 } 128 129 if (row == 0) { 130 // Initialize decoding. 131 assert(dec->alpha_plane_ != NULL); 132 dec->alph_dec_ = ALPHNew(); 133 if (dec->alph_dec_ == NULL) return NULL; 134 if (!ALPHInit(dec->alph_dec_, dec->alpha_data_, dec->alpha_data_size_, 135 width, height, dec->alpha_plane_)) { 136 ALPHDelete(dec->alph_dec_); 137 dec->alph_dec_ = NULL; 138 return NULL; 139 } 140 // if we allowed use of alpha dithering, check whether it's needed at all 141 if (dec->alph_dec_->pre_processing_ != ALPHA_PREPROCESSED_LEVELS) { 142 dec->alpha_dithering_ = 0; // disable dithering 143 } else { 144 num_rows = height; // decode everything in one pass 145 } 146 } 147 148 if (!dec->is_alpha_decoded_) { 149 int ok = 0; 150 assert(dec->alph_dec_ != NULL); 151 ok = ALPHDecode(dec, row, num_rows); 152 if (ok && dec->alpha_dithering_ > 0) { 153 ok = WebPDequantizeLevels(dec->alpha_plane_, width, height, 154 dec->alpha_dithering_); 155 } 156 if (!ok || dec->is_alpha_decoded_) { 157 ALPHDelete(dec->alph_dec_); 158 dec->alph_dec_ = NULL; 159 } 160 if (!ok) return NULL; // Error. 161 } 162 163 // Return a pointer to the current decoded row. 164 return dec->alpha_plane_ + row * width; 165 } 166