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