mirror of https://github.com/opencv/opencv.git
Open Source Computer Vision Library
https://opencv.org/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
712 lines
23 KiB
712 lines
23 KiB
// Copyright 2011 Google Inc. All Rights Reserved. |
|
// |
|
// This code is licensed under the same terms as WebM: |
|
// Software License Agreement: http://www.webmproject.org/license/software/ |
|
// Additional IP Rights Grant: http://www.webmproject.org/license/additional/ |
|
// ----------------------------------------------------------------------------- |
|
// |
|
// Set and delete APIs for mux. |
|
// |
|
// Authors: Urvang (urvang@google.com) |
|
// Vikas (vikasa@google.com) |
|
|
|
#include <assert.h> |
|
#include "./muxi.h" |
|
|
|
#if defined(__cplusplus) || defined(c_plusplus) |
|
extern "C" { |
|
#endif |
|
|
|
//------------------------------------------------------------------------------ |
|
// Life of a mux object. |
|
|
|
static void MuxInit(WebPMux* const mux) { |
|
if (mux == NULL) return; |
|
memset(mux, 0, sizeof(*mux)); |
|
} |
|
|
|
WebPMux* WebPNewInternal(int version) { |
|
if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_MUX_ABI_VERSION)) { |
|
return NULL; |
|
} else { |
|
WebPMux* const mux = (WebPMux*)malloc(sizeof(WebPMux)); |
|
// If mux is NULL MuxInit is a noop. |
|
MuxInit(mux); |
|
return mux; |
|
} |
|
} |
|
|
|
static void DeleteAllChunks(WebPChunk** const chunk_list) { |
|
while (*chunk_list) { |
|
*chunk_list = ChunkDelete(*chunk_list); |
|
} |
|
} |
|
|
|
static void MuxRelease(WebPMux* const mux) { |
|
if (mux == NULL) return; |
|
MuxImageDeleteAll(&mux->images_); |
|
DeleteAllChunks(&mux->vp8x_); |
|
DeleteAllChunks(&mux->iccp_); |
|
DeleteAllChunks(&mux->loop_); |
|
DeleteAllChunks(&mux->meta_); |
|
DeleteAllChunks(&mux->unknown_); |
|
} |
|
|
|
void WebPMuxDelete(WebPMux* mux) { |
|
// If mux is NULL MuxRelease is a noop. |
|
MuxRelease(mux); |
|
free(mux); |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// Helper method(s). |
|
|
|
// Handy MACRO, makes MuxSet() very symmetric to MuxGet(). |
|
#define SWITCH_ID_LIST(INDEX, LIST) \ |
|
if (idx == (INDEX)) { \ |
|
err = ChunkAssignData(&chunk, data, copy_data, kChunks[(INDEX)].tag); \ |
|
if (err == WEBP_MUX_OK) { \ |
|
err = ChunkSetNth(&chunk, (LIST), nth); \ |
|
} \ |
|
return err; \ |
|
} |
|
|
|
static WebPMuxError MuxSet(WebPMux* const mux, CHUNK_INDEX idx, uint32_t nth, |
|
const WebPData* const data, int copy_data) { |
|
WebPChunk chunk; |
|
WebPMuxError err = WEBP_MUX_NOT_FOUND; |
|
assert(mux != NULL); |
|
assert(!IsWPI(kChunks[idx].id)); |
|
|
|
ChunkInit(&chunk); |
|
SWITCH_ID_LIST(IDX_VP8X, &mux->vp8x_); |
|
SWITCH_ID_LIST(IDX_ICCP, &mux->iccp_); |
|
SWITCH_ID_LIST(IDX_LOOP, &mux->loop_); |
|
SWITCH_ID_LIST(IDX_META, &mux->meta_); |
|
if (idx == IDX_UNKNOWN && data->size_ > TAG_SIZE) { |
|
// For raw-data unknown chunk, the first four bytes should be the tag to be |
|
// used for the chunk. |
|
const WebPData tmp = { data->bytes_ + TAG_SIZE, data->size_ - TAG_SIZE }; |
|
err = ChunkAssignData(&chunk, &tmp, copy_data, GetLE32(data->bytes_ + 0)); |
|
if (err == WEBP_MUX_OK) |
|
err = ChunkSetNth(&chunk, &mux->unknown_, nth); |
|
} |
|
return err; |
|
} |
|
#undef SWITCH_ID_LIST |
|
|
|
static WebPMuxError MuxAddChunk(WebPMux* const mux, uint32_t nth, uint32_t tag, |
|
const uint8_t* data, size_t size, |
|
int copy_data) { |
|
const CHUNK_INDEX idx = ChunkGetIndexFromTag(tag); |
|
const WebPData chunk_data = { data, size }; |
|
assert(mux != NULL); |
|
assert(size <= MAX_CHUNK_PAYLOAD); |
|
assert(idx != IDX_NIL); |
|
return MuxSet(mux, idx, nth, &chunk_data, copy_data); |
|
} |
|
|
|
// Create data for frame/tile given image data, offsets and duration. |
|
static WebPMuxError CreateFrameTileData(const WebPData* const image, |
|
int x_offset, int y_offset, |
|
int duration, int is_lossless, |
|
int is_frame, |
|
WebPData* const frame_tile) { |
|
int width; |
|
int height; |
|
uint8_t* frame_tile_bytes; |
|
const size_t frame_tile_size = kChunks[is_frame ? IDX_FRAME : IDX_TILE].size; |
|
|
|
const int ok = is_lossless ? |
|
VP8LGetInfo(image->bytes_, image->size_, &width, &height, NULL) : |
|
VP8GetInfo(image->bytes_, image->size_, image->size_, &width, &height); |
|
if (!ok) return WEBP_MUX_INVALID_ARGUMENT; |
|
|
|
assert(width > 0 && height > 0 && duration > 0); |
|
// Note: assertion on upper bounds is done in PutLE24(). |
|
|
|
frame_tile_bytes = (uint8_t*)malloc(frame_tile_size); |
|
if (frame_tile_bytes == NULL) return WEBP_MUX_MEMORY_ERROR; |
|
|
|
PutLE24(frame_tile_bytes + 0, x_offset / 2); |
|
PutLE24(frame_tile_bytes + 3, y_offset / 2); |
|
|
|
if (is_frame) { |
|
PutLE24(frame_tile_bytes + 6, width - 1); |
|
PutLE24(frame_tile_bytes + 9, height - 1); |
|
PutLE24(frame_tile_bytes + 12, duration - 1); |
|
} |
|
|
|
frame_tile->bytes_ = frame_tile_bytes; |
|
frame_tile->size_ = frame_tile_size; |
|
return WEBP_MUX_OK; |
|
} |
|
|
|
// Outputs image data given a bitstream. The bitstream can either be a |
|
// single-image WebP file or raw VP8/VP8L data. |
|
// Also outputs 'is_lossless' to be true if the given bitstream is lossless. |
|
static WebPMuxError GetImageData(const WebPData* const bitstream, |
|
WebPData* const image, WebPData* const alpha, |
|
int* const is_lossless) { |
|
WebPDataInit(alpha); // Default: no alpha. |
|
if (bitstream->size_ < TAG_SIZE || |
|
memcmp(bitstream->bytes_, "RIFF", TAG_SIZE)) { |
|
// It is NOT webp file data. Return input data as is. |
|
*image = *bitstream; |
|
} else { |
|
// It is webp file data. Extract image data from it. |
|
const WebPMuxImage* wpi; |
|
WebPMux* const mux = WebPMuxCreate(bitstream, 0); |
|
if (mux == NULL) return WEBP_MUX_BAD_DATA; |
|
wpi = mux->images_; |
|
assert(wpi != NULL && wpi->img_ != NULL); |
|
*image = wpi->img_->data_; |
|
if (wpi->alpha_ != NULL) { |
|
*alpha = wpi->alpha_->data_; |
|
} |
|
WebPMuxDelete(mux); |
|
} |
|
*is_lossless = VP8LCheckSignature(image->bytes_, image->size_); |
|
return WEBP_MUX_OK; |
|
} |
|
|
|
static WebPMuxError DeleteChunks(WebPChunk** chunk_list, uint32_t tag) { |
|
WebPMuxError err = WEBP_MUX_NOT_FOUND; |
|
assert(chunk_list); |
|
while (*chunk_list) { |
|
WebPChunk* const chunk = *chunk_list; |
|
if (chunk->tag_ == tag) { |
|
*chunk_list = ChunkDelete(chunk); |
|
err = WEBP_MUX_OK; |
|
} else { |
|
chunk_list = &chunk->next_; |
|
} |
|
} |
|
return err; |
|
} |
|
|
|
static WebPMuxError MuxDeleteAllNamedData(WebPMux* const mux, CHUNK_INDEX idx) { |
|
const WebPChunkId id = kChunks[idx].id; |
|
WebPChunk** chunk_list; |
|
|
|
if (mux == NULL) return WEBP_MUX_INVALID_ARGUMENT; |
|
if (IsWPI(id)) return WEBP_MUX_INVALID_ARGUMENT; |
|
|
|
chunk_list = MuxGetChunkListFromId(mux, id); |
|
if (chunk_list == NULL) return WEBP_MUX_INVALID_ARGUMENT; |
|
|
|
return DeleteChunks(chunk_list, kChunks[idx].tag); |
|
} |
|
|
|
static WebPMuxError DeleteLoopCount(WebPMux* const mux) { |
|
return MuxDeleteAllNamedData(mux, IDX_LOOP); |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// Set API(s). |
|
|
|
WebPMuxError WebPMuxSetImage(WebPMux* mux, |
|
const WebPData* bitstream, int copy_data) { |
|
WebPMuxError err; |
|
WebPChunk chunk; |
|
WebPMuxImage wpi; |
|
WebPData image; |
|
WebPData alpha; |
|
int is_lossless; |
|
int image_tag; |
|
|
|
if (mux == NULL || bitstream == NULL || bitstream->bytes_ == NULL || |
|
bitstream->size_ > MAX_CHUNK_PAYLOAD) { |
|
return WEBP_MUX_INVALID_ARGUMENT; |
|
} |
|
|
|
// If given data is for a whole webp file, |
|
// extract only the VP8/VP8L data from it. |
|
err = GetImageData(bitstream, &image, &alpha, &is_lossless); |
|
if (err != WEBP_MUX_OK) return err; |
|
image_tag = is_lossless ? kChunks[IDX_VP8L].tag : kChunks[IDX_VP8].tag; |
|
|
|
// Delete the existing images. |
|
MuxImageDeleteAll(&mux->images_); |
|
|
|
MuxImageInit(&wpi); |
|
|
|
if (alpha.bytes_ != NULL) { // Add alpha chunk. |
|
ChunkInit(&chunk); |
|
err = ChunkAssignData(&chunk, &alpha, copy_data, kChunks[IDX_ALPHA].tag); |
|
if (err != WEBP_MUX_OK) goto Err; |
|
err = ChunkSetNth(&chunk, &wpi.alpha_, 1); |
|
if (err != WEBP_MUX_OK) goto Err; |
|
} |
|
|
|
// Add image chunk. |
|
ChunkInit(&chunk); |
|
err = ChunkAssignData(&chunk, &image, copy_data, image_tag); |
|
if (err != WEBP_MUX_OK) goto Err; |
|
err = ChunkSetNth(&chunk, &wpi.img_, 1); |
|
if (err != WEBP_MUX_OK) goto Err; |
|
|
|
// Add this image to mux. |
|
err = MuxImagePush(&wpi, &mux->images_); |
|
if (err != WEBP_MUX_OK) goto Err; |
|
|
|
// All OK. |
|
return WEBP_MUX_OK; |
|
|
|
Err: |
|
// Something bad happened. |
|
ChunkRelease(&chunk); |
|
MuxImageRelease(&wpi); |
|
return err; |
|
} |
|
|
|
WebPMuxError WebPMuxSetMetadata(WebPMux* mux, const WebPData* metadata, |
|
int copy_data) { |
|
WebPMuxError err; |
|
|
|
if (mux == NULL || metadata == NULL || metadata->bytes_ == NULL || |
|
metadata->size_ > MAX_CHUNK_PAYLOAD) { |
|
return WEBP_MUX_INVALID_ARGUMENT; |
|
} |
|
|
|
// Delete the existing metadata chunk(s). |
|
err = WebPMuxDeleteMetadata(mux); |
|
if (err != WEBP_MUX_OK && err != WEBP_MUX_NOT_FOUND) return err; |
|
|
|
// Add the given metadata chunk. |
|
return MuxSet(mux, IDX_META, 1, metadata, copy_data); |
|
} |
|
|
|
WebPMuxError WebPMuxSetColorProfile(WebPMux* mux, const WebPData* color_profile, |
|
int copy_data) { |
|
WebPMuxError err; |
|
|
|
if (mux == NULL || color_profile == NULL || color_profile->bytes_ == NULL || |
|
color_profile->size_ > MAX_CHUNK_PAYLOAD) { |
|
return WEBP_MUX_INVALID_ARGUMENT; |
|
} |
|
|
|
// Delete the existing ICCP chunk(s). |
|
err = WebPMuxDeleteColorProfile(mux); |
|
if (err != WEBP_MUX_OK && err != WEBP_MUX_NOT_FOUND) return err; |
|
|
|
// Add the given ICCP chunk. |
|
return MuxSet(mux, IDX_ICCP, 1, color_profile, copy_data); |
|
} |
|
|
|
WebPMuxError WebPMuxSetLoopCount(WebPMux* mux, int loop_count) { |
|
WebPMuxError err; |
|
uint8_t* data = NULL; |
|
|
|
if (mux == NULL) return WEBP_MUX_INVALID_ARGUMENT; |
|
if (loop_count >= MAX_LOOP_COUNT) return WEBP_MUX_INVALID_ARGUMENT; |
|
|
|
// Delete the existing LOOP chunk(s). |
|
err = DeleteLoopCount(mux); |
|
if (err != WEBP_MUX_OK && err != WEBP_MUX_NOT_FOUND) return err; |
|
|
|
// Add the given loop count. |
|
data = (uint8_t*)malloc(kChunks[IDX_LOOP].size); |
|
if (data == NULL) return WEBP_MUX_MEMORY_ERROR; |
|
|
|
PutLE16(data, loop_count); |
|
err = MuxAddChunk(mux, 1, kChunks[IDX_LOOP].tag, data, |
|
kChunks[IDX_LOOP].size, 1); |
|
free(data); |
|
return err; |
|
} |
|
|
|
static WebPMuxError MuxPushFrameTileInternal( |
|
WebPMux* const mux, const WebPData* const bitstream, int x_offset, |
|
int y_offset, int duration, int copy_data, uint32_t tag) { |
|
WebPChunk chunk; |
|
WebPData image; |
|
WebPData alpha; |
|
WebPMuxImage wpi; |
|
WebPMuxError err; |
|
WebPData frame_tile; |
|
const int is_frame = (tag == kChunks[IDX_FRAME].tag) ? 1 : 0; |
|
int is_lossless; |
|
int image_tag; |
|
|
|
// Sanity checks. |
|
if (mux == NULL || bitstream == NULL || bitstream->bytes_ == NULL || |
|
bitstream->size_ > MAX_CHUNK_PAYLOAD) { |
|
return WEBP_MUX_INVALID_ARGUMENT; |
|
} |
|
if (x_offset < 0 || x_offset >= MAX_POSITION_OFFSET || |
|
y_offset < 0 || y_offset >= MAX_POSITION_OFFSET || |
|
duration <= 0 || duration > MAX_DURATION) { |
|
return WEBP_MUX_INVALID_ARGUMENT; |
|
} |
|
|
|
// Snap offsets to even positions. |
|
x_offset &= ~1; |
|
y_offset &= ~1; |
|
|
|
// If given data is for a whole webp file, |
|
// extract only the VP8/VP8L data from it. |
|
err = GetImageData(bitstream, &image, &alpha, &is_lossless); |
|
if (err != WEBP_MUX_OK) return err; |
|
image_tag = is_lossless ? kChunks[IDX_VP8L].tag : kChunks[IDX_VP8].tag; |
|
|
|
WebPDataInit(&frame_tile); |
|
ChunkInit(&chunk); |
|
MuxImageInit(&wpi); |
|
|
|
if (alpha.bytes_ != NULL) { |
|
// Add alpha chunk. |
|
err = ChunkAssignData(&chunk, &alpha, copy_data, kChunks[IDX_ALPHA].tag); |
|
if (err != WEBP_MUX_OK) goto Err; |
|
err = ChunkSetNth(&chunk, &wpi.alpha_, 1); |
|
if (err != WEBP_MUX_OK) goto Err; |
|
ChunkInit(&chunk); // chunk owned by wpi.alpha_ now. |
|
} |
|
|
|
// Add image chunk. |
|
err = ChunkAssignData(&chunk, &image, copy_data, image_tag); |
|
if (err != WEBP_MUX_OK) goto Err; |
|
err = ChunkSetNth(&chunk, &wpi.img_, 1); |
|
if (err != WEBP_MUX_OK) goto Err; |
|
ChunkInit(&chunk); // chunk owned by wpi.img_ now. |
|
|
|
// Create frame/tile data. |
|
err = CreateFrameTileData(&image, x_offset, y_offset, duration, is_lossless, |
|
is_frame, &frame_tile); |
|
if (err != WEBP_MUX_OK) goto Err; |
|
|
|
// Add frame/tile chunk (with copy_data = 1). |
|
err = ChunkAssignData(&chunk, &frame_tile, 1, tag); |
|
if (err != WEBP_MUX_OK) goto Err; |
|
WebPDataClear(&frame_tile); |
|
err = ChunkSetNth(&chunk, &wpi.header_, 1); |
|
if (err != WEBP_MUX_OK) goto Err; |
|
ChunkInit(&chunk); // chunk owned by wpi.header_ now. |
|
|
|
// Add this WebPMuxImage to mux. |
|
err = MuxImagePush(&wpi, &mux->images_); |
|
if (err != WEBP_MUX_OK) goto Err; |
|
|
|
// All is well. |
|
return WEBP_MUX_OK; |
|
|
|
Err: // Something bad happened. |
|
WebPDataClear(&frame_tile); |
|
ChunkRelease(&chunk); |
|
MuxImageRelease(&wpi); |
|
return err; |
|
} |
|
|
|
WebPMuxError WebPMuxPushFrame(WebPMux* mux, const WebPData* bitstream, |
|
int x_offset, int y_offset, |
|
int duration, int copy_data) { |
|
return MuxPushFrameTileInternal(mux, bitstream, x_offset, y_offset, |
|
duration, copy_data, kChunks[IDX_FRAME].tag); |
|
} |
|
|
|
WebPMuxError WebPMuxPushTile(WebPMux* mux, const WebPData* bitstream, |
|
int x_offset, int y_offset, |
|
int copy_data) { |
|
return MuxPushFrameTileInternal(mux, bitstream, x_offset, y_offset, |
|
1 /* unused duration */, copy_data, |
|
kChunks[IDX_TILE].tag); |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// Delete API(s). |
|
|
|
WebPMuxError WebPMuxDeleteImage(WebPMux* mux) { |
|
WebPMuxError err; |
|
|
|
if (mux == NULL) return WEBP_MUX_INVALID_ARGUMENT; |
|
|
|
err = MuxValidateForImage(mux); |
|
if (err != WEBP_MUX_OK) return err; |
|
|
|
// All well, delete image. |
|
MuxImageDeleteAll(&mux->images_); |
|
return WEBP_MUX_OK; |
|
} |
|
|
|
WebPMuxError WebPMuxDeleteMetadata(WebPMux* mux) { |
|
return MuxDeleteAllNamedData(mux, IDX_META); |
|
} |
|
|
|
WebPMuxError WebPMuxDeleteColorProfile(WebPMux* mux) { |
|
return MuxDeleteAllNamedData(mux, IDX_ICCP); |
|
} |
|
|
|
static WebPMuxError DeleteFrameTileInternal(WebPMux* const mux, uint32_t nth, |
|
CHUNK_INDEX idx) { |
|
const WebPChunkId id = kChunks[idx].id; |
|
if (mux == NULL) return WEBP_MUX_INVALID_ARGUMENT; |
|
|
|
assert(idx == IDX_FRAME || idx == IDX_TILE); |
|
return MuxImageDeleteNth(&mux->images_, nth, id); |
|
} |
|
|
|
WebPMuxError WebPMuxDeleteFrame(WebPMux* mux, uint32_t nth) { |
|
return DeleteFrameTileInternal(mux, nth, IDX_FRAME); |
|
} |
|
|
|
WebPMuxError WebPMuxDeleteTile(WebPMux* mux, uint32_t nth) { |
|
return DeleteFrameTileInternal(mux, nth, IDX_TILE); |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// Assembly of the WebP RIFF file. |
|
|
|
static WebPMuxError GetFrameTileInfo(const WebPChunk* const frame_tile_chunk, |
|
int* const x_offset, int* const y_offset, |
|
int* const duration) { |
|
const uint32_t tag = frame_tile_chunk->tag_; |
|
const int is_frame = (tag == kChunks[IDX_FRAME].tag); |
|
const WebPData* const data = &frame_tile_chunk->data_; |
|
const size_t expected_data_size = |
|
is_frame ? FRAME_CHUNK_SIZE : TILE_CHUNK_SIZE; |
|
assert(frame_tile_chunk != NULL); |
|
assert(tag == kChunks[IDX_FRAME].tag || tag == kChunks[IDX_TILE].tag); |
|
if (data->size_ != expected_data_size) return WEBP_MUX_INVALID_ARGUMENT; |
|
|
|
*x_offset = 2 * GetLE24(data->bytes_ + 0); |
|
*y_offset = 2 * GetLE24(data->bytes_ + 3); |
|
if (is_frame) *duration = 1 + GetLE24(data->bytes_ + 12); |
|
return WEBP_MUX_OK; |
|
} |
|
|
|
WebPMuxError MuxGetImageWidthHeight(const WebPChunk* const image_chunk, |
|
int* const width, int* const height) { |
|
const uint32_t tag = image_chunk->tag_; |
|
const WebPData* const data = &image_chunk->data_; |
|
int w, h; |
|
int ok; |
|
assert(image_chunk != NULL); |
|
assert(tag == kChunks[IDX_VP8].tag || tag == kChunks[IDX_VP8L].tag); |
|
ok = (tag == kChunks[IDX_VP8].tag) ? |
|
VP8GetInfo(data->bytes_, data->size_, data->size_, &w, &h) : |
|
VP8LGetInfo(data->bytes_, data->size_, &w, &h, NULL); |
|
if (ok) { |
|
*width = w; |
|
*height = h; |
|
return WEBP_MUX_OK; |
|
} else { |
|
return WEBP_MUX_BAD_DATA; |
|
} |
|
} |
|
|
|
static WebPMuxError GetImageInfo(const WebPMuxImage* const wpi, |
|
int* const x_offset, int* const y_offset, |
|
int* const duration, |
|
int* const width, int* const height) { |
|
const WebPChunk* const image_chunk = wpi->img_; |
|
const WebPChunk* const frame_tile_chunk = wpi->header_; |
|
|
|
// Get offsets and duration from FRM/TILE chunk. |
|
const WebPMuxError err = |
|
GetFrameTileInfo(frame_tile_chunk, x_offset, y_offset, duration); |
|
if (err != WEBP_MUX_OK) return err; |
|
|
|
// Get width and height from VP8/VP8L chunk. |
|
return MuxGetImageWidthHeight(image_chunk, width, height); |
|
} |
|
|
|
static WebPMuxError GetImageCanvasWidthHeight( |
|
const WebPMux* const mux, uint32_t flags, |
|
int* const width, int* const height) { |
|
WebPMuxImage* wpi = NULL; |
|
assert(mux != NULL); |
|
assert(width != NULL && height != NULL); |
|
|
|
wpi = mux->images_; |
|
assert(wpi != NULL); |
|
assert(wpi->img_ != NULL); |
|
|
|
if (wpi->next_) { |
|
int max_x = 0; |
|
int max_y = 0; |
|
int64_t image_area = 0; |
|
// Aggregate the bounding box for animation frames & tiled images. |
|
for (; wpi != NULL; wpi = wpi->next_) { |
|
int x_offset, y_offset, duration, w, h; |
|
const WebPMuxError err = GetImageInfo(wpi, &x_offset, &y_offset, |
|
&duration, &w, &h); |
|
const int max_x_pos = x_offset + w; |
|
const int max_y_pos = y_offset + h; |
|
if (err != WEBP_MUX_OK) return err; |
|
assert(x_offset < MAX_POSITION_OFFSET); |
|
assert(y_offset < MAX_POSITION_OFFSET); |
|
|
|
if (max_x_pos > max_x) max_x = max_x_pos; |
|
if (max_y_pos > max_y) max_y = max_y_pos; |
|
image_area += w * h; |
|
} |
|
*width = max_x; |
|
*height = max_y; |
|
// Crude check to validate that there are no image overlaps/holes for tile |
|
// images. Check that the aggregated image area for individual tiles exactly |
|
// matches the image area of the constructed canvas. However, the area-match |
|
// is necessary but not sufficient condition. |
|
if ((flags & TILE_FLAG) && (image_area != (max_x * max_y))) { |
|
*width = 0; |
|
*height = 0; |
|
return WEBP_MUX_INVALID_ARGUMENT; |
|
} |
|
} else { |
|
// For a single image, extract the width & height from VP8/VP8L image-data. |
|
int w, h; |
|
const WebPChunk* const image_chunk = wpi->img_; |
|
const WebPMuxError err = MuxGetImageWidthHeight(image_chunk, &w, &h); |
|
if (err != WEBP_MUX_OK) return err; |
|
*width = w; |
|
*height = h; |
|
} |
|
return WEBP_MUX_OK; |
|
} |
|
|
|
// VP8X format: |
|
// Total Size : 10, |
|
// Flags : 4 bytes, |
|
// Width : 3 bytes, |
|
// Height : 3 bytes. |
|
static WebPMuxError CreateVP8XChunk(WebPMux* const mux) { |
|
WebPMuxError err = WEBP_MUX_OK; |
|
uint32_t flags = 0; |
|
int width = 0; |
|
int height = 0; |
|
uint8_t data[VP8X_CHUNK_SIZE]; |
|
const size_t data_size = VP8X_CHUNK_SIZE; |
|
const WebPMuxImage* images = NULL; |
|
|
|
assert(mux != NULL); |
|
images = mux->images_; // First image. |
|
if (images == NULL || images->img_ == NULL || |
|
images->img_->data_.bytes_ == NULL) { |
|
return WEBP_MUX_INVALID_ARGUMENT; |
|
} |
|
|
|
// If VP8X chunk(s) is(are) already present, remove them (and later add new |
|
// VP8X chunk with updated flags). |
|
err = MuxDeleteAllNamedData(mux, IDX_VP8X); |
|
if (err != WEBP_MUX_OK && err != WEBP_MUX_NOT_FOUND) return err; |
|
|
|
// Set flags. |
|
if (mux->iccp_ != NULL && mux->iccp_->data_.bytes_ != NULL) { |
|
flags |= ICCP_FLAG; |
|
} |
|
|
|
if (mux->meta_ != NULL && mux->meta_->data_.bytes_ != NULL) { |
|
flags |= META_FLAG; |
|
} |
|
|
|
if (images->header_ != NULL) { |
|
if (images->header_->tag_ == kChunks[IDX_TILE].tag) { |
|
// This is a tiled image. |
|
flags |= TILE_FLAG; |
|
} else if (images->header_->tag_ == kChunks[IDX_FRAME].tag) { |
|
// This is an image with animation. |
|
flags |= ANIMATION_FLAG; |
|
} |
|
} |
|
|
|
if (MuxImageCount(images, WEBP_CHUNK_ALPHA) > 0) { |
|
flags |= ALPHA_FLAG; // Some images have an alpha channel. |
|
} |
|
|
|
if (flags == 0) { |
|
// For Simple Image, VP8X chunk should not be added. |
|
return WEBP_MUX_OK; |
|
} |
|
|
|
err = GetImageCanvasWidthHeight(mux, flags, &width, &height); |
|
if (err != WEBP_MUX_OK) return err; |
|
|
|
if (width <= 0 || height <= 0) { |
|
return WEBP_MUX_INVALID_ARGUMENT; |
|
} |
|
if (width > MAX_CANVAS_SIZE || height > MAX_CANVAS_SIZE) { |
|
return WEBP_MUX_INVALID_ARGUMENT; |
|
} |
|
|
|
if (MuxHasLosslessImages(images)) { |
|
// We have a file with a VP8X chunk having some lossless images. |
|
// As lossless images implicitly contain alpha, force ALPHA_FLAG to be true. |
|
// Note: This 'flags' update must NOT be done for a lossless image |
|
// without a VP8X chunk! |
|
flags |= ALPHA_FLAG; |
|
} |
|
|
|
PutLE32(data + 0, flags); // VP8X chunk flags. |
|
PutLE24(data + 4, width - 1); // canvas width. |
|
PutLE24(data + 7, height - 1); // canvas height. |
|
|
|
err = MuxAddChunk(mux, 1, kChunks[IDX_VP8X].tag, data, data_size, 1); |
|
return err; |
|
} |
|
|
|
WebPMuxError WebPMuxAssemble(WebPMux* mux, WebPData* assembled_data) { |
|
size_t size = 0; |
|
uint8_t* data = NULL; |
|
uint8_t* dst = NULL; |
|
int num_frames; |
|
int num_loop_chunks; |
|
WebPMuxError err; |
|
|
|
if (mux == NULL || assembled_data == NULL) { |
|
return WEBP_MUX_INVALID_ARGUMENT; |
|
} |
|
|
|
// Remove LOOP chunk if unnecessary. |
|
err = WebPMuxNumChunks(mux, kChunks[IDX_LOOP].id, &num_loop_chunks); |
|
if (err != WEBP_MUX_OK) return err; |
|
if (num_loop_chunks >= 1) { |
|
err = WebPMuxNumChunks(mux, kChunks[IDX_FRAME].id, &num_frames); |
|
if (err != WEBP_MUX_OK) return err; |
|
if (num_frames == 0) { |
|
err = DeleteLoopCount(mux); |
|
if (err != WEBP_MUX_OK) return err; |
|
} |
|
} |
|
|
|
// Create VP8X chunk. |
|
err = CreateVP8XChunk(mux); |
|
if (err != WEBP_MUX_OK) return err; |
|
|
|
// Allocate data. |
|
size = ChunksListDiskSize(mux->vp8x_) + ChunksListDiskSize(mux->iccp_) |
|
+ ChunksListDiskSize(mux->loop_) + MuxImageListDiskSize(mux->images_) |
|
+ ChunksListDiskSize(mux->meta_) + ChunksListDiskSize(mux->unknown_) |
|
+ RIFF_HEADER_SIZE; |
|
|
|
data = (uint8_t*)malloc(size); |
|
if (data == NULL) return WEBP_MUX_MEMORY_ERROR; |
|
|
|
// Emit header & chunks. |
|
dst = MuxEmitRiffHeader(data, size); |
|
dst = ChunkListEmit(mux->vp8x_, dst); |
|
dst = ChunkListEmit(mux->iccp_, dst); |
|
dst = ChunkListEmit(mux->loop_, dst); |
|
dst = MuxImageListEmit(mux->images_, dst); |
|
dst = ChunkListEmit(mux->meta_, dst); |
|
dst = ChunkListEmit(mux->unknown_, dst); |
|
assert(dst == data + size); |
|
|
|
// Validate mux. |
|
err = MuxValidate(mux); |
|
if (err != WEBP_MUX_OK) { |
|
free(data); |
|
data = NULL; |
|
size = 0; |
|
} |
|
|
|
// Finalize. |
|
assembled_data->bytes_ = data; |
|
assembled_data->size_ = size; |
|
|
|
return err; |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
|
|
#if defined(__cplusplus) || defined(c_plusplus) |
|
} // extern "C" |
|
#endif
|
|
|