dany/libwebp
1
0
Fork 0
mirror of https://github.com/webmproject/libwebp.git synced 2024-12-25 21:28:22 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Use WebPData in MUX set APIs

Browse Source 
Change-Id: Ibdede3c1cd02c6aeef333718592da313f10f6408
This commit is contained in:
Urvang Joshi 2012-06-05 14:20:45 +05:30
parent c67bc979dd
commit 4fc4a47f6e
6 changed files with 134 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
examples/webpmux.c
View File

@ -320,16 +320,25 @@ static void PrintHelp(void) {
printf("\nINPUT & OUTPUT are in webp format.\n");
}
static int ReadFileToWebPData(const char* const filename,
WebPData* const webp_data) {
const uint8_t* data;
size_t size;
if (!ExUtilReadFile(filename, &data, &size)) return 0;
webp_data->bytes_ = data;
webp_data->size_ = size;
return 1;
}
static int CreateMux(const char* const filename, WebPMux** mux) {
size_t size = 0;
const uint8_t* data = NULL;
WebPMuxState mux_state;
WebPData bitstream;
assert(mux != NULL);
if (!ExUtilReadFile(filename, &data, &size)) return 0;
*mux = WebPMuxCreate(data, size, 1, &mux_state);
free((void*)data);
if (!ReadFileToWebPData(filename, &bitstream)) return 0;
*mux = WebPMuxCreate(&bitstream, 1, &mux_state);
free((void*)bitstream.bytes_);
if (*mux != NULL && mux_state == WEBP_MUX_STATE_COMPLETE) return 1;
fprintf(stderr, "Failed to create mux object from file %s. mux_state = %d.\n",
filename, mux_state);
@ -338,18 +347,15 @@ static int CreateMux(const char* const filename, WebPMux** mux) {
static int ReadImage(const char* filename,
WebPData* const image_ptr, WebPData* const alpha_ptr) {
const uint8_t* data = NULL;
size_t size = 0;
WebPData image, alpha;
WebPData bitstream, image, alpha;
WebPMux* mux;
WebPMuxError err;
int ok = 0;
WebPMuxState mux_state;
if (!ExUtilReadFile(filename, &data, &size)) return 0;
mux = WebPMuxCreate(data, size, 1, &mux_state);
free((void*)data);
if (!ReadFileToWebPData(filename, &bitstream)) return 0;
mux = WebPMuxCreate(&bitstream, 1, &mux_state);
free((void*)bitstream.bytes_);
if (mux == NULL || mux_state != WEBP_MUX_STATE_COMPLETE) {
fprintf(stderr,
"Failed to create mux object from file %s. mux_state = %d.\n",
@ -772,8 +778,7 @@ static int GetFrameTile(const WebPMux* mux,
err = WEBP_MUX_MEMORY_ERROR;
ERROR_GOTO2("ERROR#%d: Could not allocate a mux object.\n", err, ErrGet);
}
err = WebPMuxSetImage(mux_single, image.bytes_, image.size_,
alpha.bytes_, alpha.size_, 1);
err = WebPMuxSetImage(mux_single, &image, &alpha, 1);
if (err != WEBP_MUX_OK) {
ERROR_GOTO2("ERROR#%d: Could not create single image mux object.\n", err,
ErrGet);
@ -789,8 +794,7 @@ static int GetFrameTile(const WebPMux* mux,
static int Process(const WebPMuxConfig* config) {
WebPMux* mux = NULL;
WebPData webpdata;
const uint8_t* data = NULL;
size_t size = 0;
WebPData metadata, color_profile;
uint32_t x_offset = 0;
uint32_t y_offset = 0;
WebPMuxError err = WEBP_MUX_OK;
@ -862,8 +866,7 @@ static int Process(const WebPMuxConfig* config) {
WebPDataFree(&alpha);
ERROR_GOTO1("ERROR: Could not parse frame properties.\n", Err2);
}
err = WebPMuxAddFrame(mux, 0, image.bytes_, image.size_,
alpha.bytes_, alpha.size_,
err = WebPMuxAddFrame(mux, 0, &image, &alpha,
x_offset, y_offset, duration, 1);
WebPDataFree(&image);
WebPDataFree(&alpha);
@ -894,9 +897,7 @@ static int Process(const WebPMuxConfig* config) {
WebPDataFree(&alpha);
ERROR_GOTO1("ERROR: Could not parse tile properties.\n", Err2);
}
err = WebPMuxAddTile(mux, 0, image.bytes_, image.size_,
alpha.bytes_, alpha.size_,
x_offset, y_offset, 1);
err = WebPMuxAddTile(mux, 0, &image, &alpha, x_offset, y_offset, 1);
WebPDataFree(&image);
WebPDataFree(&alpha);
if (err != WEBP_MUX_OK) {
@ -909,10 +910,10 @@ static int Process(const WebPMuxConfig* config) {
case FEATURE_ICCP:
ok = CreateMux(config->input_, &mux);
if (!ok) goto Err2;
ok = ExUtilReadFile(feature->args_[0].filename_, &data, &size);
ok = ReadFileToWebPData(feature->args_[0].filename_, &color_profile);
if (!ok) goto Err2;
err = WebPMuxSetColorProfile(mux, data, size, 1);
free((void*)data);
err = WebPMuxSetColorProfile(mux, &color_profile, 1);
free((void*)color_profile.bytes_);
if (err != WEBP_MUX_OK) {
ERROR_GOTO2("ERROR#%d: Could not set color profile.\n", err, Err2);
}
@ -921,10 +922,10 @@ static int Process(const WebPMuxConfig* config) {
case FEATURE_XMP:
ok = CreateMux(config->input_, &mux);
if (!ok) goto Err2;
ok = ExUtilReadFile(feature->args_[0].filename_, &data, &size);
ok = ReadFileToWebPData(feature->args_[0].filename_, &metadata);
if (!ok) goto Err2;
err = WebPMuxSetMetadata(mux, data, size, 1);
free((void*)data);
err = WebPMuxSetMetadata(mux, &metadata, 1);
free((void*)metadata.bytes_);
if (err != WEBP_MUX_OK) {
ERROR_GOTO2("ERROR#%d: Could not set XMP metadata.\n", err, Err2);
}

122
src/mux/muxedit.c
View File

@ -62,9 +62,8 @@ void WebPMuxDelete(WebPMux* const mux) {
// Handy MACRO, makes MuxSet() very symmetric to MuxGet().
#define SWITCH_ID_LIST(INDEX, LIST) \
if (idx == (INDEX)) { \
err = ChunkAssignDataImageInfo(&chunk, data, size, \
image_info, \
copy_data, kChunks[(INDEX)].tag); \
err = ChunkAssignDataImageInfo(&chunk, data, image_info, copy_data, \
kChunks[(INDEX)].tag); \
if (err == WEBP_MUX_OK) { \
err = ChunkSetNth(&chunk, (LIST), nth); \
} \
@ -72,7 +71,7 @@ void WebPMuxDelete(WebPMux* const mux) {
}
static WebPMuxError MuxSet(WebPMux* const mux, CHUNK_INDEX idx, uint32_t nth,
const uint8_t* data, size_t size,
const WebPData* const data,
WebPImageInfo* image_info, int copy_data) {
WebPChunk chunk;
WebPMuxError err = WEBP_MUX_NOT_FOUND;
@ -84,11 +83,12 @@ static WebPMuxError MuxSet(WebPMux* const mux, CHUNK_INDEX idx, uint32_t nth,
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 && size > TAG_SIZE) {
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.
err = ChunkAssignDataImageInfo(&chunk, data + TAG_SIZE, size - TAG_SIZE,
image_info, copy_data, GetLE32(data + 0));
const WebPData tmp = { data->bytes_ + TAG_SIZE, data->size_ - TAG_SIZE };
err = ChunkAssignDataImageInfo(&chunk, &tmp, image_info, copy_data,
GetLE32(data->bytes_ + 0));
if (err == WEBP_MUX_OK)
err = ChunkSetNth(&chunk, &mux->unknown_, nth);
}
@ -100,11 +100,12 @@ static WebPMuxError MuxAddChunk(WebPMux* const mux, uint32_t nth, uint32_t tag,
const uint8_t* data, size_t size,
WebPImageInfo* image_info, int copy_data) {
const CHUNK_INDEX idx = ChunkGetIndexFromTag(tag);
const WebPData chunk_data = { data, size };
assert(mux != NULL);
assert(size <= MAX_CHUNK_PAYLOAD);
if (idx == IDX_NIL) return WEBP_MUX_INVALID_PARAMETER;
return MuxSet(mux, idx, nth, data, size, image_info, copy_data);
return MuxSet(mux, idx, nth, &chunk_data, image_info, copy_data);
}
static void InitImageInfo(WebPImageInfo* const image_info) {
@ -116,11 +117,13 @@ static void InitImageInfo(WebPImageInfo* const image_info) {
// Dimensions calculated from passed VP8/VP8L image data.
static WebPImageInfo* CreateImageInfo(uint32_t x_offset, uint32_t y_offset,
uint32_t duration,
const uint8_t* data, size_t size,
const WebPData* const image_data,
int is_lossless) {
int width;
int height;
WebPImageInfo* image_info = NULL;
const uint8_t* const data = image_data->bytes_;
const size_t size = image_data->size_;
const int ok = is_lossless ?
VP8LGetInfo(data, size, &width, &height, NULL) :
@ -143,7 +146,8 @@ static WebPImageInfo* CreateImageInfo(uint32_t x_offset, uint32_t y_offset,
// Create data for frame/tile given image_info.
static WebPMuxError CreateDataFromImageInfo(const WebPImageInfo* image_info,
int is_frame,
uint8_t** data, size_t* size) {
uint8_t** const data,
size_t* const size) {
assert(data);
assert(size);
assert(image_info);
@ -164,32 +168,28 @@ static WebPMuxError CreateDataFromImageInfo(const WebPImageInfo* image_info,
return WEBP_MUX_OK;
}
static int IsLosslessData(const WebPData* const image) {
return (image->size_ >= 1 && image->bytes_[0] == VP8L_MAGIC_BYTE);
}
// Outputs image data given data from a webp file (including RIFF header).
// Also outputs 'is_lossless' to be true if the given bitstream is lossless.
static WebPMuxError GetImageData(const uint8_t* data, size_t size,
static WebPMuxError GetImageData(const WebPData* const bitstream,
WebPData* const image, WebPData* const alpha,
int* const is_lossless) {
if (size < TAG_SIZE || memcmp(data, "RIFF", TAG_SIZE)) {
if (bitstream->size_ < TAG_SIZE ||
memcmp(bitstream->bytes_, "RIFF", TAG_SIZE)) {
// It is NOT webp file data. Return input data as is.
image->bytes_ = data;
image->size_ = size;
*is_lossless = IsLosslessData(image);
*image = *bitstream;
*is_lossless = VP8LCheckSignature(image->bytes_, image->size_);
return WEBP_MUX_OK;
} else {
// It is webp file data. Extract image data from it.
WebPMuxError err;
WebPMuxState mux_state;
WebPMux* const mux = WebPMuxCreate(data, size, 0, &mux_state);
WebPMux* const mux = WebPMuxCreate(bitstream, 0, &mux_state);
if (mux == NULL || mux_state != WEBP_MUX_STATE_COMPLETE) {
return WEBP_MUX_BAD_DATA;
}
err = WebPMuxGetImage(mux, image, alpha);
WebPMuxDelete(mux);
*is_lossless = IsLosslessData(image);
*is_lossless = VP8LCheckSignature(image->bytes_, image->size_);
return err;
}
}
@ -232,24 +232,25 @@ static WebPMuxError DeleteLoopCount(WebPMux* const mux) {
// Set API(s).
WebPMuxError WebPMuxSetImage(WebPMux* const mux,
const uint8_t* data, size_t size,
const uint8_t* alpha_data, size_t alpha_size,
const WebPData* const image,
const WebPData* const alpha,
int copy_data) {
WebPMuxError err;
WebPChunk chunk;
WebPMuxImage wpi;
WebPData image;
const int has_alpha = (alpha_data != NULL && alpha_size != 0);
WebPData image_raw;
const int has_alpha = (alpha != NULL && alpha->bytes_ != NULL);
int is_lossless;
int image_tag;
if (mux == NULL || data == NULL || size > MAX_CHUNK_PAYLOAD) {
if (mux == NULL || image == NULL || image->bytes_ == NULL ||
image->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(data, size, &image, NULL, &is_lossless);
err = GetImageData(image, &image_raw, NULL, &is_lossless);
if (err != WEBP_MUX_OK) return err;
image_tag = is_lossless ? kChunks[IDX_VP8L].tag : kChunks[IDX_VP8].tag;
@ -260,8 +261,8 @@ WebPMuxError WebPMuxSetImage(WebPMux* const mux,
if (has_alpha) { // Add alpha chunk.
ChunkInit(&chunk);
err = ChunkAssignDataImageInfo(&chunk, alpha_data, alpha_size, NULL,
copy_data, kChunks[IDX_ALPHA].tag);
err = ChunkAssignDataImageInfo(&chunk, alpha, NULL, copy_data,
kChunks[IDX_ALPHA].tag);
if (err != WEBP_MUX_OK) return err;
err = ChunkSetNth(&chunk, &wpi.alpha_, 1);
if (err != WEBP_MUX_OK) return err;
@ -269,8 +270,7 @@ WebPMuxError WebPMuxSetImage(WebPMux* const mux,
// Add image chunk.
ChunkInit(&chunk);
err = ChunkAssignDataImageInfo(&chunk, image.bytes_, image.size_, NULL,
copy_data, image_tag);
err = ChunkAssignDataImageInfo(&chunk, &image_raw, NULL, copy_data, image_tag);
if (err != WEBP_MUX_OK) return err;
err = ChunkSetNth(&chunk, &wpi.img_, 1);
if (err != WEBP_MUX_OK) return err;
@ -280,11 +280,12 @@ WebPMuxError WebPMuxSetImage(WebPMux* const mux,
}
WebPMuxError WebPMuxSetMetadata(WebPMux* const mux,
const uint8_t* data, size_t size,
const WebPData* const metadata,
int copy_data) {
WebPMuxError err;
if (mux == NULL || data == NULL || size > MAX_CHUNK_PAYLOAD) {
if (mux == NULL || metadata == NULL || metadata->bytes_ == NULL ||
metadata->size_ > MAX_CHUNK_PAYLOAD) {
return WEBP_MUX_INVALID_ARGUMENT;
}
@ -293,15 +294,16 @@ WebPMuxError WebPMuxSetMetadata(WebPMux* const mux,
if (err != WEBP_MUX_OK && err != WEBP_MUX_NOT_FOUND) return err;
// Add the given metadata chunk.
return MuxSet(mux, IDX_META, 1, data, size, NULL, copy_data);
return MuxSet(mux, IDX_META, 1, metadata, NULL, copy_data);
}
WebPMuxError WebPMuxSetColorProfile(WebPMux* const mux,
const uint8_t* data, size_t size,
const WebPData* const color_profile,
int copy_data) {
WebPMuxError err;
if (mux == NULL || data == NULL || size > MAX_CHUNK_PAYLOAD) {
if (mux == NULL || color_profile == NULL || color_profile->bytes_ == NULL ||
color_profile->size_ > MAX_CHUNK_PAYLOAD) {
return WEBP_MUX_INVALID_ARGUMENT;
}
@ -310,7 +312,7 @@ WebPMuxError WebPMuxSetColorProfile(WebPMux* const mux,
if (err != WEBP_MUX_OK && err != WEBP_MUX_NOT_FOUND) return err;
// Add the given ICCP chunk.
return MuxSet(mux, IDX_ICCP, 1, data, size, NULL, copy_data);
return MuxSet(mux, IDX_ICCP, 1, color_profile, NULL, copy_data);
}
WebPMuxError WebPMuxSetLoopCount(WebPMux* const mux, uint32_t loop_count) {
@ -336,29 +338,30 @@ WebPMuxError WebPMuxSetLoopCount(WebPMux* const mux, uint32_t loop_count) {
static WebPMuxError MuxAddFrameTileInternal(
WebPMux* const mux, uint32_t nth,
const uint8_t* data, size_t size,
const uint8_t* alpha_data, size_t alpha_size,
const WebPData* const image, const WebPData* const alpha,
uint32_t x_offset, uint32_t y_offset, uint32_t duration,
int copy_data, uint32_t tag) {
WebPChunk chunk;
WebPData image;
WebPData image_raw;
WebPMuxImage wpi;
WebPMuxError err;
WebPImageInfo* image_info = NULL;
uint8_t* frame_tile_data = NULL;
size_t frame_tile_data_size = 0;
size_t frame_tile_size = 0;
WebPData frame_tile;
const int is_frame = (tag == kChunks[IDX_FRAME].tag) ? 1 : 0;
const int has_alpha = (alpha_data != NULL && alpha_size != 0);
const int has_alpha = (alpha != NULL && alpha->bytes_ != NULL);
int is_lossless;
int image_tag;
if (mux == NULL || data == NULL || size > MAX_CHUNK_PAYLOAD) {
if (mux == NULL || image == NULL || image->bytes_ == NULL ||
image->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(data, size, &image, NULL, &is_lossless);
err = GetImageData(image, &image_raw, NULL, &is_lossless);
if (err != WEBP_MUX_OK) return err;
image_tag = is_lossless ? kChunks[IDX_VP8L].tag : kChunks[IDX_VP8].tag;
@ -367,8 +370,8 @@ static WebPMuxError MuxAddFrameTileInternal(
if (has_alpha) {
// Add alpha chunk.
err = ChunkAssignDataImageInfo(&chunk, alpha_data, alpha_size, NULL,
copy_data, kChunks[IDX_ALPHA].tag);
err = ChunkAssignDataImageInfo(&chunk, alpha, NULL, copy_data,
kChunks[IDX_ALPHA].tag);
if (err != WEBP_MUX_OK) return err;
err = ChunkSetNth(&chunk, &wpi.alpha_, 1);
if (err != WEBP_MUX_OK) return err;
@ -376,16 +379,16 @@ static WebPMuxError MuxAddFrameTileInternal(
}
// Create image_info object.
image_info = CreateImageInfo(x_offset, y_offset, duration,
image.bytes_, image.size_, is_lossless);
image_info = CreateImageInfo(x_offset, y_offset, duration, &image_raw,
is_lossless);
if (image_info == NULL) {
MuxImageRelease(&wpi);
return WEBP_MUX_MEMORY_ERROR;
}
// Add image chunk.
err = ChunkAssignDataImageInfo(&chunk, image.bytes_, image.size_, image_info,
copy_data, image_tag);
err = ChunkAssignDataImageInfo(&chunk, &image_raw, image_info, copy_data,
image_tag);
if (err != WEBP_MUX_OK) goto Err;
image_info = NULL; // Owned by 'chunk' now.
err = ChunkSetNth(&chunk, &wpi.img_, 1);
@ -394,12 +397,13 @@ static WebPMuxError MuxAddFrameTileInternal(
// Create frame/tile data from image_info.
err = CreateDataFromImageInfo(wpi.img_->image_info_, is_frame,
&frame_tile_data, &frame_tile_data_size);
&frame_tile_data, &frame_tile_size);
if (err != WEBP_MUX_OK) goto Err;
// Add frame/tile chunk (with copy_data = 1).
err = ChunkAssignDataImageInfo(&chunk, frame_tile_data, frame_tile_data_size,
NULL, 1, tag);
frame_tile.bytes_ = frame_tile_data;
frame_tile.size_ = frame_tile_size;
err = ChunkAssignDataImageInfo(&chunk, &frame_tile, NULL, 1, tag);
if (err != WEBP_MUX_OK) goto Err;
free(frame_tile_data);
frame_tile_data = NULL;
@ -425,21 +429,21 @@ static WebPMuxError MuxAddFrameTileInternal(
// TODO(urvang): Think about whether we need 'nth' while adding a frame or tile.
WebPMuxError WebPMuxAddFrame(WebPMux* const mux, uint32_t nth,
const uint8_t* data, size_t size,
const uint8_t* alpha_data, size_t alpha_size,
const WebPData* const image,
const WebPData* const alpha,
uint32_t x_offset, uint32_t y_offset,
uint32_t duration, int copy_data) {
return MuxAddFrameTileInternal(mux, nth, data, size, alpha_data, alpha_size,
return MuxAddFrameTileInternal(mux, nth, image, alpha,
x_offset, y_offset, duration,
copy_data, kChunks[IDX_FRAME].tag);
}
WebPMuxError WebPMuxAddTile(WebPMux* const mux, uint32_t nth,
const uint8_t* data, size_t size,
const uint8_t* alpha_data, size_t alpha_size,
const WebPData* const image,
const WebPData* const alpha,
uint32_t x_offset, uint32_t y_offset,
int copy_data) {
return MuxAddFrameTileInternal(mux, nth, data, size, alpha_data, alpha_size,
return MuxAddFrameTileInternal(mux, nth, image, alpha,
x_offset, y_offset, 1,
copy_data, kChunks[IDX_TILE].tag);
}

2
src/mux/muxi.h
View File

@ -163,7 +163,7 @@ WebPChunk* ChunkSearchList(WebPChunk* first, uint32_t nth, uint32_t tag);
// Fill the chunk with the given data & image_info.
WebPMuxError ChunkAssignDataImageInfo(WebPChunk* chunk,
const uint8_t* data, size_t data_size,
const WebPData* const data,
WebPImageInfo* image_info,
int copy_data, uint32_t tag);

17
src/mux/muxinternal.c
View File

@ -132,7 +132,7 @@ static int ChunkSearchListToSet(WebPChunk** chunk_list, uint32_t nth,
// Chunk writer methods.
WebPMuxError ChunkAssignDataImageInfo(WebPChunk* chunk,
const uint8_t* data, size_t data_size,
const WebPData* const data,
WebPImageInfo* image_info,
int copy_data, uint32_t tag) {
// For internally allocated chunks, always copy data & make it owner of data.
@ -141,26 +141,21 @@ WebPMuxError ChunkAssignDataImageInfo(WebPChunk* chunk,
}
ChunkRelease(chunk);
if (data == NULL) {
data_size = 0;
} else if (data_size == 0) {
data = NULL;
}
if (data != NULL) {
if (copy_data) {
// Copy data.
chunk->data_ = (uint8_t*)malloc(data_size);
chunk->data_ = (uint8_t*)malloc(data->size_);
if (chunk->data_ == NULL) return WEBP_MUX_MEMORY_ERROR;
memcpy((uint8_t*)chunk->data_, data, data_size);
chunk->payload_size_ = data_size;
memcpy((uint8_t*)chunk->data_, data->bytes_, data->size_);
chunk->payload_size_ = data->size_;
// Chunk is owner of data.
chunk->owner_ = 1;
} else {
// Don't copy data.
chunk->data_ = data;
chunk->payload_size_ = data_size;
chunk->data_ = data->bytes_;
chunk->payload_size_ = data->size_;
}
}

16
src/mux/muxread.c
View File

@ -55,6 +55,7 @@ static WebPMuxError ChunkAssignData(WebPChunk* chunk, const uint8_t* data,
size_t data_size, size_t riff_size,
int copy_data) {
uint32_t chunk_size;
WebPData chunk_data;
// Sanity checks.
if (data_size < TAG_SIZE) return WEBP_MUX_NOT_ENOUGH_DATA;
@ -67,25 +68,34 @@ static WebPMuxError ChunkAssignData(WebPChunk* chunk, const uint8_t* data,
}
// Data assignment.
return ChunkAssignDataImageInfo(chunk, data + CHUNK_HEADER_SIZE, chunk_size,
NULL, copy_data, GetLE32(data + 0));
chunk_data.bytes_ = data + CHUNK_HEADER_SIZE;
chunk_data.size_ = chunk_size;
return ChunkAssignDataImageInfo(chunk, &chunk_data, NULL, copy_data,
GetLE32(data + 0));
}
//------------------------------------------------------------------------------
// Create a mux object from WebP-RIFF data.
WebPMux* WebPMuxCreateInternal(const uint8_t* data, size_t size, int copy_data,
WebPMux* WebPMuxCreateInternal(const WebPData* const bitstream, int copy_data,
WebPMuxState* const mux_state, int version) {
size_t riff_size;
uint32_t tag;
const uint8_t* end;
WebPMux* mux = NULL;
WebPMuxImage* wpi = NULL;
const uint8_t* data;
size_t size;
if (mux_state) *mux_state = WEBP_MUX_STATE_PARTIAL;
// Sanity checks.
if (version != WEBP_MUX_ABI_VERSION) goto Err; // version mismatch
if (bitstream == NULL) goto Err;
data = bitstream->bytes_;
size = bitstream->size_;
if (data == NULL) goto Err;
if (size < RIFF_HEADER_SIZE) return NULL;
if (GetLE32(data + 0) != mktag('R', 'I', 'F', 'F') ||

61
src/webp/mux.h
View File

@ -18,12 +18,11 @@
// int copy_data = 0;
// WebPMux* mux = WebPMuxNew();
// // ... (Prepare image data).
// WebPMuxSetImage(mux, image_data, image_data_size, alpha_data, alpha_size,
// copy_data);
// WebPMuxSetImage(mux, image_data, alpha_data, copy_data);
// // ... (Prepare ICCP color profile data).
// WebPMuxSetColorProfile(mux, icc_data, icc_data_size, copy_data);
// WebPMuxSetColorProfile(mux, icc_data, copy_data);
// // ... (Prepare XMP metadata).
// WebPMuxSetMetadata(mux, xmp_data, xmp_data_size, copy_data);
// WebPMuxSetMetadata(mux, xmp_data, copy_data);
// // Get data from mux in WebP RIFF format.
// WebPMuxAssemble(mux, &output_data, &output_data_size);
// WebPMuxDelete(mux);
@ -34,7 +33,7 @@
//
// int copy_data = 0;
// // ... (Read data from file).
// WebPMux* mux = WebPMuxCreate(data, data_size, copy_data, NULL);
// WebPMux* mux = WebPMuxCreate(data, copy_data, NULL);
// WebPMuxGetImage(mux, &image, &alpha);
// // ... (Consume image; e.g. call WebPDecode() to decode the data).
// WebPMuxGetColorProfile(mux, &icc_profile);
@ -111,13 +110,12 @@ WEBP_EXTERN(void) WebPMuxDelete(WebPMux* const mux);
// Mux creation.
// Internal, version-checked, entry point
WEBP_EXTERN(WebPMux*) WebPMuxCreateInternal(const uint8_t*, size_t,
WEBP_EXTERN(WebPMux*) WebPMuxCreateInternal(const WebPData* const,
int, WebPMuxState* const, int);
// Creates a mux object from raw data given in WebP RIFF format.
// Parameters:
// data - (in) the raw data in WebP RIFF format
// size - (in) size of raw data
// bitstream - (in) the bitstream data in WebP RIFF format
// copy_data - (in) value 1 indicates given data WILL copied to the mux, and
// value 0 indicates data will NOT be copied.
// mux_state - (out) indicates the state of the mux returned. Can be passed
@ -125,11 +123,11 @@ WEBP_EXTERN(WebPMux*) WebPMuxCreateInternal(const uint8_t*, size_t,
// Returns:
// A pointer to the mux object created from given data - on success.
// NULL - In case of invalid data or memory error.
static WEBP_INLINE WebPMux* WebPMuxCreate(const uint8_t* data, size_t size,
static WEBP_INLINE WebPMux* WebPMuxCreate(const WebPData* const bitstream,
int copy_data,
WebPMuxState* const mux_state) {
return WebPMuxCreateInternal(
data, size, copy_data, mux_state, WEBP_MUX_ABI_VERSION);
bitstream, copy_data, mux_state, WEBP_MUX_ABI_VERSION);
}
//------------------------------------------------------------------------------
@ -139,11 +137,9 @@ static WEBP_INLINE WebPMux* WebPMuxCreate(const uint8_t* data, size_t size,
// will be removed.
// Parameters:
// mux - (in/out) object in which the image is to be set
// data - (in) the image data to be set. The data can be either a VP8/VP8L
// image - (in) the image data. The data can be either a VP8/VP8L
// bitstream or a single-image WebP file (non-animated & non-tiled)
// size - (in) size of the image data
// alpha_data - (in) the alpha data corresponding to the image (if present)
// alpha_size - (in) size of alpha chunk data
// alpha - (in) the alpha data of the image (if present)
// copy_data - (in) value 1 indicates given data WILL copied to the mux, and
// value 0 indicates data will NOT be copied.
// Returns:
@ -152,8 +148,7 @@ static WEBP_INLINE WebPMux* WebPMuxCreate(const uint8_t* data, size_t size,
// WEBP_MUX_OK - on success.
WEBP_EXTERN(WebPMuxError) WebPMuxSetImage(
WebPMux* const mux,
const uint8_t* data, size_t size,
const uint8_t* alpha_data, size_t alpha_size,
const WebPData* const image, const WebPData* const alpha,
int copy_data);
// Gets a reference to the image in the mux object.
@ -188,8 +183,7 @@ WEBP_EXTERN(WebPMuxError) WebPMuxDeleteImage(WebPMux* const mux);
// be removed.
// Parameters:
// mux - (in/out) object to which the XMP metadata is to be added
// data - (in) the XMP metadata data to be added
// size - (in) size of the XMP metadata data
// metadata - (in) the XMP metadata data to be added
// copy_data - (in) value 1 indicates given data WILL copied to the mux, and
// value 0 indicates data will NOT be copied.
// Returns:
@ -197,7 +191,7 @@ WEBP_EXTERN(WebPMuxError) WebPMuxDeleteImage(WebPMux* const mux);
// WEBP_MUX_MEMORY_ERROR - on memory allocation error.
// WEBP_MUX_OK - on success.
WEBP_EXTERN(WebPMuxError) WebPMuxSetMetadata(
WebPMux* const mux, const uint8_t* data, size_t size, int copy_data);
WebPMux* const mux, const WebPData* const metadata, int copy_data);
// Gets a reference to the XMP metadata in the mux object.
// The caller should NOT free the returned data.
@ -227,8 +221,7 @@ WEBP_EXTERN(WebPMuxError) WebPMuxDeleteMetadata(WebPMux* const mux);
// will be removed.
// Parameters:
// mux - (in/out) object to which the color profile is to be added
// data - (in) the color profile data to be added
// size - (in) size of the color profile data
// color_profile - (in) the color profile data to be added
// copy_data - (in) value 1 indicates given data WILL copied to the mux, and
// value 0 indicates data will NOT be copied.
// Returns:
@ -236,7 +229,7 @@ WEBP_EXTERN(WebPMuxError) WebPMuxDeleteMetadata(WebPMux* const mux);
// WEBP_MUX_MEMORY_ERROR - on memory allocation error
// WEBP_MUX_OK - on success
WEBP_EXTERN(WebPMuxError) WebPMuxSetColorProfile(
WebPMux* const mux, const uint8_t* data, size_t size, int copy_data);
WebPMux* const mux, const WebPData* const color_profile, int copy_data);
// Gets a reference to the color profile in the mux object.
// The caller should NOT free the returned data.
@ -267,12 +260,10 @@ WEBP_EXTERN(WebPMuxError) WebPMuxDeleteColorProfile(WebPMux* const mux);
// Parameters:
// mux - (in/out) object to which an animation frame is to be added
// nth - (in) The position at which the frame is to be added.
// data - (in) the raw VP8/VP8L image data corresponding to frame image. The
// image - (in) the raw VP8/VP8L image data corresponding to frame image. The
// data can be either a VP8/VP8L bitstream or a single-image WebP file
// (non-animated & non-tiled)
// size - (in) size of frame chunk data
// alpha_data - (in) the alpha data corresponding to frame image (if present)
// alpha_size - (in) size of alpha chunk data
// alpha - (in) the alpha data corresponding to frame image (if present)
// x_offset - (in) x-offset of the frame to be added
// y_offset - (in) y-offset of the frame to be added
// duration - (in) duration of the frame to be added (in milliseconds)
@ -285,18 +276,15 @@ WEBP_EXTERN(WebPMuxError) WebPMuxDeleteColorProfile(WebPMux* const mux);
// WEBP_MUX_OK - on success.
WEBP_EXTERN(WebPMuxError) WebPMuxAddFrame(
WebPMux* const mux, uint32_t nth,
const uint8_t* data, size_t size,
const uint8_t* alpha_data, size_t alpha_size,
const WebPData* const image, const WebPData* const alpha,
uint32_t x_offset, uint32_t y_offset, uint32_t duration,
int copy_data);
// TODO(urvang): Create a struct as follows to reduce argument list size:
// typedef struct {
// int nth;
// uint8_t* data;
// uint32_t data_size;
// uint8_t* alpha;
// uint32_t alpha_size;
// WebPData image;
// WebPData alpha;
// uint32_t x_offset, y_offset;
// uint32_t duration;
// } FrameInfo;
@ -367,12 +355,10 @@ WEBP_EXTERN(WebPMuxError) WebPMuxGetLoopCount(const WebPMux* const mux,
// Parameters:
// mux - (in/out) object to which a tile is to be added
// nth - (in) The position at which the tile is to be added.
// data - (in) the raw VP8/VP8L image data corresponding to tile image. The
// image - (in) the raw VP8/VP8L image data corresponding to tile image. The
// data can be either a VP8/VP8L bitstream or a single-image WebP file
// (non-animated & non-tiled)
// size - (in) size of tile chunk data
// alpha_data - (in) the alpha data corresponding to tile image (if present)
// alpha_size - (in) size of alpha chunk data
// alpha - (in) the alpha data corresponding to tile image (if present)
// x_offset - (in) x-offset of the tile to be added
// y_offset - (in) y-offset of the tile to be added
// copy_data - (in) value 1 indicates given data WILL copied to the mux, and
@ -384,8 +370,7 @@ WEBP_EXTERN(WebPMuxError) WebPMuxGetLoopCount(const WebPMux* const mux,
// WEBP_MUX_OK - on success.
WEBP_EXTERN(WebPMuxError) WebPMuxAddTile(
WebPMux* const mux, uint32_t nth,
const uint8_t* data, size_t size,
const uint8_t* alpha_data, size_t alpha_size,
const WebPData* const image, const WebPData* const alpha,
uint32_t x_offset, uint32_t y_offset,
int copy_data);