← Back to branch summary

~paparazzi-uav/paparazzi/v5.0-manual

« back to all changes in this revision

Viewing changes to sw/ext/opencv_bebop/opencv/3rdparty/libwebp/mux/muxedit.c

  • Committer: Paparazzi buildbot
  • Date: 2016-05-18 15:00:29 UTC
  • Revision ID: felix.ruess+docbot@gmail.com-20160518150029-e8lgzi5kvb4p7un9
Manual import commit 4b8bbb730080dac23cf816b98908dacfabe2a8ec from v5.0 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sw/ext/opencv_bebop/opencv/3rdparty/libwebp/mux/muxedit.c
 
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
// Set and delete APIs for mux.
 
11
//
 
12
// Authors: Urvang (urvang@google.com)
 
13
//          Vikas (vikasa@google.com)
 
14
 
 
15
#include <assert.h>
 
16
#include "./muxi.h"
 
17
#include "../utils/utils.h"
 
18
 
 
19
#if defined(__cplusplus) || defined(c_plusplus)
 
20
extern "C" {
 
21
#endif
 
22
 
 
23
//------------------------------------------------------------------------------
 
24
// Life of a mux object.
 
25
 
 
26
static void MuxInit(WebPMux* const mux) {
 
27
  if (mux == NULL) return;
 
28
  memset(mux, 0, sizeof(*mux));
 
29
}
 
30
 
 
31
WebPMux* WebPNewInternal(int version) {
 
32
  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_MUX_ABI_VERSION)) {
 
33
    return NULL;
 
34
  } else {
 
35
    WebPMux* const mux = (WebPMux*)malloc(sizeof(WebPMux));
 
36
    // If mux is NULL MuxInit is a noop.
 
37
    MuxInit(mux);
 
38
    return mux;
 
39
  }
 
40
}
 
41
 
 
42
static void DeleteAllChunks(WebPChunk** const chunk_list) {
 
43
  while (*chunk_list) {
 
44
    *chunk_list = ChunkDelete(*chunk_list);
 
45
  }
 
46
}
 
47
 
 
48
static void MuxRelease(WebPMux* const mux) {
 
49
  if (mux == NULL) return;
 
50
  MuxImageDeleteAll(&mux->images_);
 
51
  DeleteAllChunks(&mux->vp8x_);
 
52
  DeleteAllChunks(&mux->iccp_);
 
53
  DeleteAllChunks(&mux->anim_);
 
54
  DeleteAllChunks(&mux->exif_);
 
55
  DeleteAllChunks(&mux->xmp_);
 
56
  DeleteAllChunks(&mux->unknown_);
 
57
}
 
58
 
 
59
void WebPMuxDelete(WebPMux* mux) {
 
60
  // If mux is NULL MuxRelease is a noop.
 
61
  MuxRelease(mux);
 
62
  free(mux);
 
63
}
 
64
 
 
65
//------------------------------------------------------------------------------
 
66
// Helper method(s).
 
67
 
 
68
// Handy MACRO, makes MuxSet() very symmetric to MuxGet().
 
69
#define SWITCH_ID_LIST(INDEX, LIST)                                            \
 
70
  if (idx == (INDEX)) {                                                        \
 
71
    err = ChunkAssignData(&chunk, data, copy_data, kChunks[(INDEX)].tag);      \
 
72
    if (err == WEBP_MUX_OK) {                                                  \
 
73
      err = ChunkSetNth(&chunk, (LIST), nth);                                  \
 
74
    }                                                                          \
 
75
    return err;                                                                \
 
76
  }
 
77
 
 
78
static WebPMuxError MuxSet(WebPMux* const mux, CHUNK_INDEX idx, uint32_t nth,
 
79
                           const WebPData* const data, int copy_data) {
 
80
  WebPChunk chunk;
 
81
  WebPMuxError err = WEBP_MUX_NOT_FOUND;
 
82
  assert(mux != NULL);
 
83
  assert(!IsWPI(kChunks[idx].id));
 
84
 
 
85
  ChunkInit(&chunk);
 
86
  SWITCH_ID_LIST(IDX_VP8X, &mux->vp8x_);
 
87
  SWITCH_ID_LIST(IDX_ICCP, &mux->iccp_);
 
88
  SWITCH_ID_LIST(IDX_ANIM, &mux->anim_);
 
89
  SWITCH_ID_LIST(IDX_EXIF, &mux->exif_);
 
90
  SWITCH_ID_LIST(IDX_XMP,  &mux->xmp_);
 
91
  if (idx == IDX_UNKNOWN && data->size > TAG_SIZE) {
 
92
    // For raw-data unknown chunk, the first four bytes should be the tag to be
 
93
    // used for the chunk.
 
94
    const WebPData tmp = { data->bytes + TAG_SIZE, data->size - TAG_SIZE };
 
95
    err = ChunkAssignData(&chunk, &tmp, copy_data, GetLE32(data->bytes + 0));
 
96
    if (err == WEBP_MUX_OK)
 
97
      err = ChunkSetNth(&chunk, &mux->unknown_, nth);
 
98
  }
 
99
  return err;
 
100
}
 
101
#undef SWITCH_ID_LIST
 
102
 
 
103
static WebPMuxError MuxAddChunk(WebPMux* const mux, uint32_t nth, uint32_t tag,
 
104
                                const uint8_t* data, size_t size,
 
105
                                int copy_data) {
 
106
  const CHUNK_INDEX idx = ChunkGetIndexFromTag(tag);
 
107
  const WebPData chunk_data = { data, size };
 
108
  assert(mux != NULL);
 
109
  assert(size <= MAX_CHUNK_PAYLOAD);
 
110
  assert(idx != IDX_NIL);
 
111
  return MuxSet(mux, idx, nth, &chunk_data, copy_data);
 
112
}
 
113
 
 
114
// Create data for frame/fragment given image data, offsets and duration.
 
115
static WebPMuxError CreateFrameFragmentData(
 
116
    const WebPData* const image, int x_offset, int y_offset, int duration,
 
117
    WebPMuxAnimDispose dispose_method, int is_lossless, int is_frame,
 
118
    WebPData* const frame_frgm) {
 
119
  int width;
 
120
  int height;
 
121
  uint8_t* frame_frgm_bytes;
 
122
  const size_t frame_frgm_size = kChunks[is_frame ? IDX_ANMF : IDX_FRGM].size;
 
123
 
 
124
  const int ok = is_lossless ?
 
125
      VP8LGetInfo(image->bytes, image->size, &width, &height, NULL) :
 
126
      VP8GetInfo(image->bytes, image->size, image->size, &width, &height);
 
127
  if (!ok) return WEBP_MUX_INVALID_ARGUMENT;
 
128
 
 
129
  assert(width > 0 && height > 0 && duration >= 0);
 
130
  assert(dispose_method == (dispose_method & 1));
 
131
  // Note: assertion on upper bounds is done in PutLE24().
 
132
 
 
133
  frame_frgm_bytes = (uint8_t*)malloc(frame_frgm_size);
 
134
  if (frame_frgm_bytes == NULL) return WEBP_MUX_MEMORY_ERROR;
 
135
 
 
136
  PutLE24(frame_frgm_bytes + 0, x_offset / 2);
 
137
  PutLE24(frame_frgm_bytes + 3, y_offset / 2);
 
138
 
 
139
  if (is_frame) {
 
140
    PutLE24(frame_frgm_bytes + 6, width - 1);
 
141
    PutLE24(frame_frgm_bytes + 9, height - 1);
 
142
    PutLE24(frame_frgm_bytes + 12, duration);
 
143
    frame_frgm_bytes[15] = (dispose_method & 1);
 
144
  }
 
145
 
 
146
  frame_frgm->bytes = frame_frgm_bytes;
 
147
  frame_frgm->size = frame_frgm_size;
 
148
  return WEBP_MUX_OK;
 
149
}
 
150
 
 
151
// Outputs image data given a bitstream. The bitstream can either be a
 
152
// single-image WebP file or raw VP8/VP8L data.
 
153
// Also outputs 'is_lossless' to be true if the given bitstream is lossless.
 
154
static WebPMuxError GetImageData(const WebPData* const bitstream,
 
155
                                 WebPData* const image, WebPData* const alpha,
 
156
                                 int* const is_lossless) {
 
157
  WebPDataInit(alpha);  // Default: no alpha.
 
158
  if (bitstream->size < TAG_SIZE ||
 
159
      memcmp(bitstream->bytes, "RIFF", TAG_SIZE)) {
 
160
    // It is NOT webp file data. Return input data as is.
 
161
    *image = *bitstream;
 
162
  } else {
 
163
    // It is webp file data. Extract image data from it.
 
164
    const WebPMuxImage* wpi;
 
165
    WebPMux* const mux = WebPMuxCreate(bitstream, 0);
 
166
    if (mux == NULL) return WEBP_MUX_BAD_DATA;
 
167
    wpi = mux->images_;
 
168
    assert(wpi != NULL && wpi->img_ != NULL);
 
169
    *image = wpi->img_->data_;
 
170
    if (wpi->alpha_ != NULL) {
 
171
      *alpha = wpi->alpha_->data_;
 
172
    }
 
173
    WebPMuxDelete(mux);
 
174
  }
 
175
  *is_lossless = VP8LCheckSignature(image->bytes, image->size);
 
176
  return WEBP_MUX_OK;
 
177
}
 
178
 
 
179
static WebPMuxError DeleteChunks(WebPChunk** chunk_list, uint32_t tag) {
 
180
  WebPMuxError err = WEBP_MUX_NOT_FOUND;
 
181
  assert(chunk_list);
 
182
  while (*chunk_list) {
 
183
    WebPChunk* const chunk = *chunk_list;
 
184
    if (chunk->tag_ == tag) {
 
185
      *chunk_list = ChunkDelete(chunk);
 
186
      err = WEBP_MUX_OK;
 
187
    } else {
 
188
      chunk_list = &chunk->next_;
 
189
    }
 
190
  }
 
191
  return err;
 
192
}
 
193
 
 
194
static WebPMuxError MuxDeleteAllNamedData(WebPMux* const mux, uint32_t tag) {
 
195
  const WebPChunkId id = ChunkGetIdFromTag(tag);
 
196
  WebPChunk** chunk_list;
 
197
 
 
198
  assert(mux != NULL);
 
199
  if (IsWPI(id)) return WEBP_MUX_INVALID_ARGUMENT;
 
200
 
 
201
  chunk_list = MuxGetChunkListFromId(mux, id);
 
202
  if (chunk_list == NULL) return WEBP_MUX_INVALID_ARGUMENT;
 
203
 
 
204
  return DeleteChunks(chunk_list, tag);
 
205
}
 
206
 
 
207
//------------------------------------------------------------------------------
 
208
// Set API(s).
 
209
 
 
210
WebPMuxError WebPMuxSetChunk(WebPMux* mux, const char fourcc[4],
 
211
                             const WebPData* chunk_data, int copy_data) {
 
212
  CHUNK_INDEX idx;
 
213
  uint32_t tag;
 
214
  WebPMuxError err;
 
215
  if (mux == NULL || fourcc == NULL || chunk_data == NULL ||
 
216
      chunk_data->bytes == NULL || chunk_data->size > MAX_CHUNK_PAYLOAD) {
 
217
    return WEBP_MUX_INVALID_ARGUMENT;
 
218
  }
 
219
  idx = ChunkGetIndexFromFourCC(fourcc);
 
220
  tag = ChunkGetTagFromFourCC(fourcc);
 
221
 
 
222
  // Delete existing chunk(s) with the same 'fourcc'.
 
223
  err = MuxDeleteAllNamedData(mux, tag);
 
224
  if (err != WEBP_MUX_OK && err != WEBP_MUX_NOT_FOUND) return err;
 
225
 
 
226
  // Add the given chunk.
 
227
  return MuxSet(mux, idx, 1, chunk_data, copy_data);
 
228
}
 
229
 
 
230
// Creates a chunk from given 'data' and sets it as 1st chunk in 'chunk_list'.
 
231
static WebPMuxError AddDataToChunkList(
 
232
    const WebPData* const data, int copy_data, uint32_t tag,
 
233
    WebPChunk** chunk_list) {
 
234
  WebPChunk chunk;
 
235
  WebPMuxError err;
 
236
  ChunkInit(&chunk);
 
237
  err = ChunkAssignData(&chunk, data, copy_data, tag);
 
238
  if (err != WEBP_MUX_OK) goto Err;
 
239
  err = ChunkSetNth(&chunk, chunk_list, 1);
 
240
  if (err != WEBP_MUX_OK) goto Err;
 
241
  return WEBP_MUX_OK;
 
242
 Err:
 
243
  ChunkRelease(&chunk);
 
244
  return err;
 
245
}
 
246
 
 
247
// Extracts image & alpha data from the given bitstream and then sets wpi.alpha_
 
248
// and wpi.img_ appropriately.
 
249
static WebPMuxError SetAlphaAndImageChunks(
 
250
    const WebPData* const bitstream, int copy_data, WebPMuxImage* const wpi) {
 
251
  int is_lossless = 0;
 
252
  WebPData image, alpha;
 
253
  WebPMuxError err = GetImageData(bitstream, &image, &alpha, &is_lossless);
 
254
  const int image_tag =
 
255
      is_lossless ? kChunks[IDX_VP8L].tag : kChunks[IDX_VP8].tag;
 
256
  if (err != WEBP_MUX_OK) return err;
 
257
  if (alpha.bytes != NULL) {
 
258
    err = AddDataToChunkList(&alpha, copy_data, kChunks[IDX_ALPHA].tag,
 
259
                             &wpi->alpha_);
 
260
    if (err != WEBP_MUX_OK) return err;
 
261
  }
 
262
  return AddDataToChunkList(&image, copy_data, image_tag, &wpi->img_);
 
263
}
 
264
 
 
265
WebPMuxError WebPMuxSetImage(WebPMux* mux, const WebPData* bitstream,
 
266
                             int copy_data) {
 
267
  WebPMuxImage wpi;
 
268
  WebPMuxError err;
 
269
 
 
270
  // Sanity checks.
 
271
  if (mux == NULL || bitstream == NULL || bitstream->bytes == NULL ||
 
272
      bitstream->size > MAX_CHUNK_PAYLOAD) {
 
273
    return WEBP_MUX_INVALID_ARGUMENT;
 
274
  }
 
275
 
 
276
  if (mux->images_ != NULL) {
 
277
    // Only one 'simple image' can be added in mux. So, remove present images.
 
278
    MuxImageDeleteAll(&mux->images_);
 
279
  }
 
280
 
 
281
  MuxImageInit(&wpi);
 
282
  err = SetAlphaAndImageChunks(bitstream, copy_data, &wpi);
 
283
  if (err != WEBP_MUX_OK) goto Err;
 
284
 
 
285
  // Add this WebPMuxImage to mux.
 
286
  err = MuxImagePush(&wpi, &mux->images_);
 
287
  if (err != WEBP_MUX_OK) goto Err;
 
288
 
 
289
  // All is well.
 
290
  return WEBP_MUX_OK;
 
291
 
 
292
 Err:  // Something bad happened.
 
293
  MuxImageRelease(&wpi);
 
294
  return err;
 
295
}
 
296
 
 
297
WebPMuxError WebPMuxPushFrame(WebPMux* mux, const WebPMuxFrameInfo* frame,
 
298
                              int copy_data) {
 
299
  WebPMuxImage wpi;
 
300
  WebPMuxError err;
 
301
  int is_frame;
 
302
  const WebPData* const bitstream = &frame->bitstream;
 
303
 
 
304
  // Sanity checks.
 
305
  if (mux == NULL || frame == NULL) return WEBP_MUX_INVALID_ARGUMENT;
 
306
 
 
307
  is_frame = (frame->id == WEBP_CHUNK_ANMF);
 
308
  if (!(is_frame || (frame->id == WEBP_CHUNK_FRGM))) {
 
309
    return WEBP_MUX_INVALID_ARGUMENT;
 
310
  }
 
311
#ifndef WEBP_EXPERIMENTAL_FEATURES
 
312
  if (frame->id == WEBP_CHUNK_FRGM) {     // disabled for now.
 
313
    return WEBP_MUX_INVALID_ARGUMENT;
 
314
  }
 
315
#endif
 
316
 
 
317
  if (bitstream->bytes == NULL || bitstream->size > MAX_CHUNK_PAYLOAD) {
 
318
    return WEBP_MUX_INVALID_ARGUMENT;
 
319
  }
 
320
 
 
321
  if (mux->images_ != NULL) {
 
322
    const WebPMuxImage* const image = mux->images_;
 
323
    const uint32_t image_id = (image->header_ != NULL) ?
 
324
        ChunkGetIdFromTag(image->header_->tag_) : WEBP_CHUNK_IMAGE;
 
325
    if (image_id != frame->id) {
 
326
      return WEBP_MUX_INVALID_ARGUMENT;  // Conflicting frame types.
 
327
    }
 
328
  }
 
329
 
 
330
  MuxImageInit(&wpi);
 
331
  err = SetAlphaAndImageChunks(bitstream, copy_data, &wpi);
 
332
  if (err != WEBP_MUX_OK) goto Err;
 
333
  assert(wpi.img_ != NULL);  // As SetAlphaAndImageChunks() was successful.
 
334
 
 
335
  {
 
336
    const int is_lossless = (wpi.img_->tag_ == kChunks[IDX_VP8L].tag);
 
337
    const int x_offset = frame->x_offset & ~1;  // Snap offsets to even.
 
338
    const int y_offset = frame->y_offset & ~1;
 
339
    const int duration = is_frame ? frame->duration : 1 /* unused */;
 
340
    const WebPMuxAnimDispose dispose_method =
 
341
        is_frame ? frame->dispose_method : 0 /* unused */;
 
342
    const uint32_t tag = kChunks[is_frame ? IDX_ANMF : IDX_FRGM].tag;
 
343
    WebPData frame_frgm;
 
344
    if (x_offset < 0 || x_offset >= MAX_POSITION_OFFSET ||
 
345
        y_offset < 0 || y_offset >= MAX_POSITION_OFFSET ||
 
346
        (duration < 0 || duration >= MAX_DURATION) ||
 
347
        dispose_method != (dispose_method & 1)) {
 
348
      err = WEBP_MUX_INVALID_ARGUMENT;
 
349
      goto Err;
 
350
    }
 
351
    err = CreateFrameFragmentData(&wpi.img_->data_, x_offset, y_offset,
 
352
                                  duration, dispose_method, is_lossless,
 
353
                                  is_frame, &frame_frgm);
 
354
    if (err != WEBP_MUX_OK) goto Err;
 
355
    // Add frame/fragment chunk (with copy_data = 1).
 
356
    err = AddDataToChunkList(&frame_frgm, 1, tag, &wpi.header_);
 
357
    WebPDataClear(&frame_frgm);  // frame_frgm owned by wpi.header_ now.
 
358
    if (err != WEBP_MUX_OK) goto Err;
 
359
  }
 
360
 
 
361
  // Add this WebPMuxImage to mux.
 
362
  err = MuxImagePush(&wpi, &mux->images_);
 
363
  if (err != WEBP_MUX_OK) goto Err;
 
364
 
 
365
  // All is well.
 
366
  return WEBP_MUX_OK;
 
367
 
 
368
 Err:  // Something bad happened.
 
369
  MuxImageRelease(&wpi);
 
370
  return err;
 
371
}
 
372
 
 
373
WebPMuxError WebPMuxSetAnimationParams(WebPMux* mux,
 
374
                                       const WebPMuxAnimParams* params) {
 
375
  WebPMuxError err;
 
376
  uint8_t data[ANIM_CHUNK_SIZE];
 
377
 
 
378
  if (mux == NULL || params == NULL) return WEBP_MUX_INVALID_ARGUMENT;
 
379
  if (params->loop_count < 0 || params->loop_count >= MAX_LOOP_COUNT) {
 
380
    return WEBP_MUX_INVALID_ARGUMENT;
 
381
  }
 
382
 
 
383
  // Delete any existing ANIM chunk(s).
 
384
  err = MuxDeleteAllNamedData(mux, kChunks[IDX_ANIM].tag);
 
385
  if (err != WEBP_MUX_OK && err != WEBP_MUX_NOT_FOUND) return err;
 
386
 
 
387
  // Set the animation parameters.
 
388
  PutLE32(data, params->bgcolor);
 
389
  PutLE16(data + 4, params->loop_count);
 
390
  return MuxAddChunk(mux, 1, kChunks[IDX_ANIM].tag, data, sizeof(data), 1);
 
391
}
 
392
 
 
393
//------------------------------------------------------------------------------
 
394
// Delete API(s).
 
395
 
 
396
WebPMuxError WebPMuxDeleteChunk(WebPMux* mux, const char fourcc[4]) {
 
397
  if (mux == NULL || fourcc == NULL) return WEBP_MUX_INVALID_ARGUMENT;
 
398
  return MuxDeleteAllNamedData(mux, ChunkGetTagFromFourCC(fourcc));
 
399
}
 
400
 
 
401
WebPMuxError WebPMuxDeleteFrame(WebPMux* mux, uint32_t nth) {
 
402
  if (mux == NULL) return WEBP_MUX_INVALID_ARGUMENT;
 
403
  return MuxImageDeleteNth(&mux->images_, nth);
 
404
}
 
405
 
 
406
//------------------------------------------------------------------------------
 
407
// Assembly of the WebP RIFF file.
 
408
 
 
409
static WebPMuxError GetFrameFragmentInfo(
 
410
    const WebPChunk* const frame_frgm_chunk,
 
411
    int* const x_offset, int* const y_offset, int* const duration) {
 
412
  const uint32_t tag = frame_frgm_chunk->tag_;
 
413
  const int is_frame = (tag == kChunks[IDX_ANMF].tag);
 
414
  const WebPData* const data = &frame_frgm_chunk->data_;
 
415
  const size_t expected_data_size =
 
416
      is_frame ? ANMF_CHUNK_SIZE : FRGM_CHUNK_SIZE;
 
417
  assert(frame_frgm_chunk != NULL);
 
418
  assert(tag == kChunks[IDX_ANMF].tag || tag ==  kChunks[IDX_FRGM].tag);
 
419
  if (data->size != expected_data_size) return WEBP_MUX_INVALID_ARGUMENT;
 
420
 
 
421
  *x_offset = 2 * GetLE24(data->bytes + 0);
 
422
  *y_offset = 2 * GetLE24(data->bytes + 3);
 
423
  if (is_frame) *duration = GetLE24(data->bytes + 12);
 
424
  return WEBP_MUX_OK;
 
425
}
 
426
 
 
427
WebPMuxError MuxGetImageWidthHeight(const WebPChunk* const image_chunk,
 
428
                                    int* const width, int* const height) {
 
429
  const uint32_t tag = image_chunk->tag_;
 
430
  const WebPData* const data = &image_chunk->data_;
 
431
  int w, h;
 
432
  int ok;
 
433
  assert(image_chunk != NULL);
 
434
  assert(tag == kChunks[IDX_VP8].tag || tag ==  kChunks[IDX_VP8L].tag);
 
435
  ok = (tag == kChunks[IDX_VP8].tag) ?
 
436
      VP8GetInfo(data->bytes, data->size, data->size, &w, &h) :
 
437
      VP8LGetInfo(data->bytes, data->size, &w, &h, NULL);
 
438
  if (ok) {
 
439
    *width = w;
 
440
    *height = h;
 
441
    return WEBP_MUX_OK;
 
442
  } else {
 
443
    return WEBP_MUX_BAD_DATA;
 
444
  }
 
445
}
 
446
 
 
447
static WebPMuxError GetImageInfo(const WebPMuxImage* const wpi,
 
448
                                 int* const x_offset, int* const y_offset,
 
449
                                 int* const duration,
 
450
                                 int* const width, int* const height) {
 
451
  const WebPChunk* const image_chunk = wpi->img_;
 
452
  const WebPChunk* const frame_frgm_chunk = wpi->header_;
 
453
 
 
454
  // Get offsets and duration from ANMF/FRGM chunk.
 
455
  const WebPMuxError err =
 
456
      GetFrameFragmentInfo(frame_frgm_chunk, x_offset, y_offset, duration);
 
457
  if (err != WEBP_MUX_OK) return err;
 
458
 
 
459
  // Get width and height from VP8/VP8L chunk.
 
460
  return MuxGetImageWidthHeight(image_chunk, width, height);
 
461
}
 
462
 
 
463
static WebPMuxError GetImageCanvasWidthHeight(
 
464
    const WebPMux* const mux, uint32_t flags,
 
465
    int* const width, int* const height) {
 
466
  WebPMuxImage* wpi = NULL;
 
467
  assert(mux != NULL);
 
468
  assert(width != NULL && height != NULL);
 
469
 
 
470
  wpi = mux->images_;
 
471
  assert(wpi != NULL);
 
472
  assert(wpi->img_ != NULL);
 
473
 
 
474
  if (wpi->next_) {
 
475
    int max_x = 0;
 
476
    int max_y = 0;
 
477
    int64_t image_area = 0;
 
478
    // Aggregate the bounding box for animation frames & fragmented images.
 
479
    for (; wpi != NULL; wpi = wpi->next_) {
 
480
      int x_offset = 0, y_offset = 0, duration = 0, w = 0, h = 0;
 
481
      const WebPMuxError err = GetImageInfo(wpi, &x_offset, &y_offset,
 
482
                                            &duration, &w, &h);
 
483
      const int max_x_pos = x_offset + w;
 
484
      const int max_y_pos = y_offset + h;
 
485
      if (err != WEBP_MUX_OK) return err;
 
486
      assert(x_offset < MAX_POSITION_OFFSET);
 
487
      assert(y_offset < MAX_POSITION_OFFSET);
 
488
 
 
489
      if (max_x_pos > max_x) max_x = max_x_pos;
 
490
      if (max_y_pos > max_y) max_y = max_y_pos;
 
491
      image_area += w * h;
 
492
    }
 
493
    *width = max_x;
 
494
    *height = max_y;
 
495
    // Crude check to validate that there are no image overlaps/holes for
 
496
    // fragmented images. Check that the aggregated image area for individual
 
497
    // fragments exactly matches the image area of the constructed canvas.
 
498
    // However, the area-match is necessary but not sufficient condition.
 
499
    if ((flags & FRAGMENTS_FLAG) && (image_area != (max_x * max_y))) {
 
500
      *width = 0;
 
501
      *height = 0;
 
502
      return WEBP_MUX_INVALID_ARGUMENT;
 
503
    }
 
504
  } else {
 
505
    // For a single image, extract the width & height from VP8/VP8L image-data.
 
506
    int w, h;
 
507
    const WebPChunk* const image_chunk = wpi->img_;
 
508
    const WebPMuxError err = MuxGetImageWidthHeight(image_chunk, &w, &h);
 
509
    if (err != WEBP_MUX_OK) return err;
 
510
    *width = w;
 
511
    *height = h;
 
512
  }
 
513
  return WEBP_MUX_OK;
 
514
}
 
515
 
 
516
// VP8X format:
 
517
// Total Size : 10,
 
518
// Flags  : 4 bytes,
 
519
// Width  : 3 bytes,
 
520
// Height : 3 bytes.
 
521
static WebPMuxError CreateVP8XChunk(WebPMux* const mux) {
 
522
  WebPMuxError err = WEBP_MUX_OK;
 
523
  uint32_t flags = 0;
 
524
  int width = 0;
 
525
  int height = 0;
 
526
  uint8_t data[VP8X_CHUNK_SIZE];
 
527
  const size_t data_size = VP8X_CHUNK_SIZE;
 
528
  const WebPMuxImage* images = NULL;
 
529
 
 
530
  assert(mux != NULL);
 
531
  images = mux->images_;  // First image.
 
532
  if (images == NULL || images->img_ == NULL ||
 
533
      images->img_->data_.bytes == NULL) {
 
534
    return WEBP_MUX_INVALID_ARGUMENT;
 
535
  }
 
536
 
 
537
  // If VP8X chunk(s) is(are) already present, remove them (and later add new
 
538
  // VP8X chunk with updated flags).
 
539
  err = MuxDeleteAllNamedData(mux, kChunks[IDX_VP8X].tag);
 
540
  if (err != WEBP_MUX_OK && err != WEBP_MUX_NOT_FOUND) return err;
 
541
 
 
542
  // Set flags.
 
543
  if (mux->iccp_ != NULL && mux->iccp_->data_.bytes != NULL) {
 
544
    flags |= ICCP_FLAG;
 
545
  }
 
546
  if (mux->exif_ != NULL && mux->exif_->data_.bytes != NULL) {
 
547
    flags |= EXIF_FLAG;
 
548
  }
 
549
  if (mux->xmp_ != NULL && mux->xmp_->data_.bytes != NULL) {
 
550
    flags |= XMP_FLAG;
 
551
  }
 
552
  if (images->header_ != NULL) {
 
553
    if (images->header_->tag_ == kChunks[IDX_FRGM].tag) {
 
554
      // This is a fragmented image.
 
555
      flags |= FRAGMENTS_FLAG;
 
556
    } else if (images->header_->tag_ == kChunks[IDX_ANMF].tag) {
 
557
      // This is an image with animation.
 
558
      flags |= ANIMATION_FLAG;
 
559
    }
 
560
  }
 
561
  if (MuxImageCount(images, WEBP_CHUNK_ALPHA) > 0) {
 
562
    flags |= ALPHA_FLAG;  // Some images have an alpha channel.
 
563
  }
 
564
 
 
565
  if (flags == 0) {
 
566
    // For Simple Image, VP8X chunk should not be added.
 
567
    return WEBP_MUX_OK;
 
568
  }
 
569
 
 
570
  err = GetImageCanvasWidthHeight(mux, flags, &width, &height);
 
571
  if (err != WEBP_MUX_OK) return err;
 
572
 
 
573
  if (width <= 0 || height <= 0) {
 
574
    return WEBP_MUX_INVALID_ARGUMENT;
 
575
  }
 
576
  if (width > MAX_CANVAS_SIZE || height > MAX_CANVAS_SIZE) {
 
577
    return WEBP_MUX_INVALID_ARGUMENT;
 
578
  }
 
579
 
 
580
  if (MuxHasLosslessImages(images)) {
 
581
    // We have a file with a VP8X chunk having some lossless images.
 
582
    // As lossless images implicitly contain alpha, force ALPHA_FLAG to be true.
 
583
    // Note: This 'flags' update must NOT be done for a lossless image
 
584
    // without a VP8X chunk!
 
585
    flags |= ALPHA_FLAG;
 
586
  }
 
587
 
 
588
  PutLE32(data + 0, flags);   // VP8X chunk flags.
 
589
  PutLE24(data + 4, width - 1);   // canvas width.
 
590
  PutLE24(data + 7, height - 1);  // canvas height.
 
591
 
 
592
  err = MuxAddChunk(mux, 1, kChunks[IDX_VP8X].tag, data, data_size, 1);
 
593
  return err;
 
594
}
 
595
 
 
596
// Cleans up 'mux' by removing any unnecessary chunks.
 
597
static WebPMuxError MuxCleanup(WebPMux* const mux) {
 
598
  int num_frames;
 
599
  int num_fragments;
 
600
  int num_anim_chunks;
 
601
 
 
602
  // If we have an image with single fragment or frame, convert it to a
 
603
  // non-animated non-fragmented image (to avoid writing FRGM/ANMF chunk
 
604
  // unnecessarily).
 
605
  WebPMuxError err = WebPMuxNumChunks(mux, kChunks[IDX_ANMF].id, &num_frames);
 
606
  if (err != WEBP_MUX_OK) return err;
 
607
  err = WebPMuxNumChunks(mux, kChunks[IDX_FRGM].id, &num_fragments);
 
608
  if (err != WEBP_MUX_OK) return err;
 
609
  if (num_frames == 1 || num_fragments == 1) {
 
610
    WebPMuxImage* frame_frag;
 
611
    err = MuxImageGetNth((const WebPMuxImage**)&mux->images_, 1, &frame_frag);
 
612
    assert(err == WEBP_MUX_OK);  // We know that one frame/fragment does exist.
 
613
    if (frame_frag->header_ != NULL) {
 
614
      assert(frame_frag->header_->tag_ == kChunks[IDX_ANMF].tag ||
 
615
             frame_frag->header_->tag_ == kChunks[IDX_FRGM].tag);
 
616
      ChunkDelete(frame_frag->header_);  // Removes ANMF/FRGM chunk.
 
617
      frame_frag->header_ = NULL;
 
618
    }
 
619
    num_frames = 0;
 
620
    num_fragments = 0;
 
621
  }
 
622
  // Remove ANIM chunk if this is a non-animated image.
 
623
  err = WebPMuxNumChunks(mux, kChunks[IDX_ANIM].id, &num_anim_chunks);
 
624
  if (err != WEBP_MUX_OK) return err;
 
625
  if (num_anim_chunks >= 1 && num_frames == 0) {
 
626
    err = MuxDeleteAllNamedData(mux, kChunks[IDX_ANIM].tag);
 
627
    if (err != WEBP_MUX_OK) return err;
 
628
  }
 
629
  return WEBP_MUX_OK;
 
630
}
 
631
 
 
632
WebPMuxError WebPMuxAssemble(WebPMux* mux, WebPData* assembled_data) {
 
633
  size_t size = 0;
 
634
  uint8_t* data = NULL;
 
635
  uint8_t* dst = NULL;
 
636
  WebPMuxError err;
 
637
 
 
638
  if (mux == NULL || assembled_data == NULL) {
 
639
    return WEBP_MUX_INVALID_ARGUMENT;
 
640
  }
 
641
 
 
642
  // Finalize mux.
 
643
  err = MuxCleanup(mux);
 
644
  if (err != WEBP_MUX_OK) return err;
 
645
  err = CreateVP8XChunk(mux);
 
646
  if (err != WEBP_MUX_OK) return err;
 
647
 
 
648
  // Allocate data.
 
649
  size = ChunksListDiskSize(mux->vp8x_) + ChunksListDiskSize(mux->iccp_)
 
650
       + ChunksListDiskSize(mux->anim_) + MuxImageListDiskSize(mux->images_)
 
651
       + ChunksListDiskSize(mux->exif_) + ChunksListDiskSize(mux->xmp_)
 
652
       + ChunksListDiskSize(mux->unknown_) + RIFF_HEADER_SIZE;
 
653
 
 
654
  data = (uint8_t*)malloc(size);
 
655
  if (data == NULL) return WEBP_MUX_MEMORY_ERROR;
 
656
 
 
657
  // Emit header & chunks.
 
658
  dst = MuxEmitRiffHeader(data, size);
 
659
  dst = ChunkListEmit(mux->vp8x_, dst);
 
660
  dst = ChunkListEmit(mux->iccp_, dst);
 
661
  dst = ChunkListEmit(mux->anim_, dst);
 
662
  dst = MuxImageListEmit(mux->images_, dst);
 
663
  dst = ChunkListEmit(mux->exif_, dst);
 
664
  dst = ChunkListEmit(mux->xmp_, dst);
 
665
  dst = ChunkListEmit(mux->unknown_, dst);
 
666
  assert(dst == data + size);
 
667
 
 
668
  // Validate mux.
 
669
  err = MuxValidate(mux);
 
670
  if (err != WEBP_MUX_OK) {
 
671
    free(data);
 
672
    data = NULL;
 
673
    size = 0;
 
674
  }
 
675
 
 
676
  // Finalize data.
 
677
  assembled_data->bytes = data;
 
678
  assembled_data->size = size;
 
679
 
 
680
  return err;
 
681
}
 
682
 
 
683
//------------------------------------------------------------------------------
 
684
 
 
685
#if defined(__cplusplus) || defined(c_plusplus)
 
686
}    // extern "C"
 
687
#endif