• 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 // Read APIs for mux.
11 //
12 // Authors: Urvang (urvang@google.com)
13 //          Vikas (vikasa@google.com)
14 
15 #include <assert.h>
16 #include "src/mux/muxi.h"
17 #include "src/utils/utils.h"
18 
19 //------------------------------------------------------------------------------
20 // Helper method(s).
21 
22 // Handy MACRO.
23 #define SWITCH_ID_LIST(INDEX, LIST)                                           \
24   if (idx == (INDEX)) {                                                       \
25     const WebPChunk* const chunk = ChunkSearchList((LIST), nth,               \
26                                                    kChunks[(INDEX)].tag);     \
27     if (chunk) {                                                              \
28       *data = chunk->data_;                                                   \
29       return WEBP_MUX_OK;                                                     \
30     } else {                                                                  \
31       return WEBP_MUX_NOT_FOUND;                                              \
32     }                                                                         \
33   }
34 
MuxGet(const WebPMux * const mux,CHUNK_INDEX idx,uint32_t nth,WebPData * const data)35 static WebPMuxError MuxGet(const WebPMux* const mux, CHUNK_INDEX idx,
36                            uint32_t nth, WebPData* const data) {
37   assert(mux != NULL);
38   assert(!IsWPI(kChunks[idx].id));
39   WebPDataInit(data);
40 
41   SWITCH_ID_LIST(IDX_VP8X, mux->vp8x_);
42   SWITCH_ID_LIST(IDX_ICCP, mux->iccp_);
43   SWITCH_ID_LIST(IDX_ANIM, mux->anim_);
44   SWITCH_ID_LIST(IDX_EXIF, mux->exif_);
45   SWITCH_ID_LIST(IDX_XMP, mux->xmp_);
46   assert(idx != IDX_UNKNOWN);
47   return WEBP_MUX_NOT_FOUND;
48 }
49 #undef SWITCH_ID_LIST
50 
51 // Fill the chunk with the given data (includes chunk header bytes), after some
52 // verifications.
ChunkVerifyAndAssign(WebPChunk * chunk,const uint8_t * data,size_t data_size,size_t riff_size,int copy_data)53 static WebPMuxError ChunkVerifyAndAssign(WebPChunk* chunk,
54                                          const uint8_t* data, size_t data_size,
55                                          size_t riff_size, int copy_data) {
56   uint32_t chunk_size;
57   WebPData chunk_data;
58 
59   // Sanity checks.
60   if (data_size < CHUNK_HEADER_SIZE) return WEBP_MUX_NOT_ENOUGH_DATA;
61   chunk_size = GetLE32(data + TAG_SIZE);
62   if (chunk_size > MAX_CHUNK_PAYLOAD) return WEBP_MUX_BAD_DATA;
63 
64   {
65     const size_t chunk_disk_size = SizeWithPadding(chunk_size);
66     if (chunk_disk_size > riff_size) return WEBP_MUX_BAD_DATA;
67     if (chunk_disk_size > data_size) return WEBP_MUX_NOT_ENOUGH_DATA;
68   }
69 
70   // Data assignment.
71   chunk_data.bytes = data + CHUNK_HEADER_SIZE;
72   chunk_data.size = chunk_size;
73   return ChunkAssignData(chunk, &chunk_data, copy_data, GetLE32(data + 0));
74 }
75 
MuxImageFinalize(WebPMuxImage * const wpi)76 int MuxImageFinalize(WebPMuxImage* const wpi) {
77   const WebPChunk* const img = wpi->img_;
78   const WebPData* const image = &img->data_;
79   const int is_lossless = (img->tag_ == kChunks[IDX_VP8L].tag);
80   int w, h;
81   int vp8l_has_alpha = 0;
82   const int ok = is_lossless ?
83       VP8LGetInfo(image->bytes, image->size, &w, &h, &vp8l_has_alpha) :
84       VP8GetInfo(image->bytes, image->size, image->size, &w, &h);
85   assert(img != NULL);
86   if (ok) {
87     // Ignore ALPH chunk accompanying VP8L.
88     if (is_lossless && (wpi->alpha_ != NULL)) {
89       ChunkDelete(wpi->alpha_);
90       wpi->alpha_ = NULL;
91     }
92     wpi->width_ = w;
93     wpi->height_ = h;
94     wpi->has_alpha_ = vp8l_has_alpha || (wpi->alpha_ != NULL);
95   }
96   return ok;
97 }
98 
MuxImageParse(const WebPChunk * const chunk,int copy_data,WebPMuxImage * const wpi)99 static int MuxImageParse(const WebPChunk* const chunk, int copy_data,
100                          WebPMuxImage* const wpi) {
101   const uint8_t* bytes = chunk->data_.bytes;
102   size_t size = chunk->data_.size;
103   const uint8_t* const last = bytes + size;
104   WebPChunk subchunk;
105   size_t subchunk_size;
106   WebPChunk** unknown_chunk_list = &wpi->unknown_;
107   ChunkInit(&subchunk);
108 
109   assert(chunk->tag_ == kChunks[IDX_ANMF].tag);
110   assert(!wpi->is_partial_);
111 
112   // ANMF.
113   {
114     const size_t hdr_size = ANMF_CHUNK_SIZE;
115     const WebPData temp = { bytes, hdr_size };
116     // Each of ANMF chunk contain a header at the beginning. So, its size should
117     // be at least 'hdr_size'.
118     if (size < hdr_size) goto Fail;
119     ChunkAssignData(&subchunk, &temp, copy_data, chunk->tag_);
120   }
121   ChunkSetHead(&subchunk, &wpi->header_);
122   wpi->is_partial_ = 1;  // Waiting for ALPH and/or VP8/VP8L chunks.
123 
124   // Rest of the chunks.
125   subchunk_size = ChunkDiskSize(&subchunk) - CHUNK_HEADER_SIZE;
126   bytes += subchunk_size;
127   size -= subchunk_size;
128 
129   while (bytes != last) {
130     ChunkInit(&subchunk);
131     if (ChunkVerifyAndAssign(&subchunk, bytes, size, size,
132                              copy_data) != WEBP_MUX_OK) {
133       goto Fail;
134     }
135     switch (ChunkGetIdFromTag(subchunk.tag_)) {
136       case WEBP_CHUNK_ALPHA:
137         if (wpi->alpha_ != NULL) goto Fail;  // Consecutive ALPH chunks.
138         if (ChunkSetHead(&subchunk, &wpi->alpha_) != WEBP_MUX_OK) goto Fail;
139         wpi->is_partial_ = 1;  // Waiting for a VP8 chunk.
140         break;
141       case WEBP_CHUNK_IMAGE:
142         if (wpi->img_ != NULL) goto Fail;  // Only 1 image chunk allowed.
143         if (ChunkSetHead(&subchunk, &wpi->img_) != WEBP_MUX_OK) goto Fail;
144         if (!MuxImageFinalize(wpi)) goto Fail;
145         wpi->is_partial_ = 0;  // wpi is completely filled.
146         break;
147       case WEBP_CHUNK_UNKNOWN:
148         if (wpi->is_partial_) {
149           goto Fail;  // Encountered an unknown chunk
150                       // before some image chunks.
151         }
152         if (ChunkAppend(&subchunk, &unknown_chunk_list) != WEBP_MUX_OK) {
153           goto Fail;
154         }
155         break;
156       default:
157         goto Fail;
158         break;
159     }
160     subchunk_size = ChunkDiskSize(&subchunk);
161     bytes += subchunk_size;
162     size -= subchunk_size;
163   }
164   if (wpi->is_partial_) goto Fail;
165   return 1;
166 
167  Fail:
168   ChunkRelease(&subchunk);
169   return 0;
170 }
171 
172 //------------------------------------------------------------------------------
173 // Create a mux object from WebP-RIFF data.
174 
WebPMuxCreateInternal(const WebPData * bitstream,int copy_data,int version)175 WebPMux* WebPMuxCreateInternal(const WebPData* bitstream, int copy_data,
176                                int version) {
177   size_t riff_size;
178   uint32_t tag;
179   const uint8_t* end;
180   WebPMux* mux = NULL;
181   WebPMuxImage* wpi = NULL;
182   const uint8_t* data;
183   size_t size;
184   WebPChunk chunk;
185   // Stores the end of the chunk lists so that it is faster to append data to
186   // their ends.
187   WebPChunk** chunk_list_ends[WEBP_CHUNK_NIL + 1] = { NULL };
188   ChunkInit(&chunk);
189 
190   // Sanity checks.
191   if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_MUX_ABI_VERSION)) {
192     return NULL;  // version mismatch
193   }
194   if (bitstream == NULL) return NULL;
195 
196   data = bitstream->bytes;
197   size = bitstream->size;
198 
199   if (data == NULL) return NULL;
200   if (size < RIFF_HEADER_SIZE + CHUNK_HEADER_SIZE) return NULL;
201   if (GetLE32(data + 0) != MKFOURCC('R', 'I', 'F', 'F') ||
202       GetLE32(data + CHUNK_HEADER_SIZE) != MKFOURCC('W', 'E', 'B', 'P')) {
203     return NULL;
204   }
205 
206   mux = WebPMuxNew();
207   if (mux == NULL) return NULL;
208 
209   tag = GetLE32(data + RIFF_HEADER_SIZE);
210   if (tag != kChunks[IDX_VP8].tag &&
211       tag != kChunks[IDX_VP8L].tag &&
212       tag != kChunks[IDX_VP8X].tag) {
213     goto Err;  // First chunk should be VP8, VP8L or VP8X.
214   }
215 
216   riff_size = GetLE32(data + TAG_SIZE);
217   if (riff_size > MAX_CHUNK_PAYLOAD) goto Err;
218 
219   // Note this padding is historical and differs from demux.c which does not
220   // pad the file size.
221   riff_size = SizeWithPadding(riff_size);
222   if (riff_size < CHUNK_HEADER_SIZE) goto Err;
223   if (riff_size > size) goto Err;
224   // There's no point in reading past the end of the RIFF chunk.
225   if (size > riff_size + CHUNK_HEADER_SIZE) {
226     size = riff_size + CHUNK_HEADER_SIZE;
227   }
228 
229   end = data + size;
230   data += RIFF_HEADER_SIZE;
231   size -= RIFF_HEADER_SIZE;
232 
233   wpi = (WebPMuxImage*)WebPSafeMalloc(1ULL, sizeof(*wpi));
234   if (wpi == NULL) goto Err;
235   MuxImageInit(wpi);
236 
237   // Loop over chunks.
238   while (data != end) {
239     size_t data_size;
240     WebPChunkId id;
241     if (ChunkVerifyAndAssign(&chunk, data, size, riff_size,
242                              copy_data) != WEBP_MUX_OK) {
243       goto Err;
244     }
245     data_size = ChunkDiskSize(&chunk);
246     id = ChunkGetIdFromTag(chunk.tag_);
247     switch (id) {
248       case WEBP_CHUNK_ALPHA:
249         if (wpi->alpha_ != NULL) goto Err;  // Consecutive ALPH chunks.
250         if (ChunkSetHead(&chunk, &wpi->alpha_) != WEBP_MUX_OK) goto Err;
251         wpi->is_partial_ = 1;  // Waiting for a VP8 chunk.
252         break;
253       case WEBP_CHUNK_IMAGE:
254         if (ChunkSetHead(&chunk, &wpi->img_) != WEBP_MUX_OK) goto Err;
255         if (!MuxImageFinalize(wpi)) goto Err;
256         wpi->is_partial_ = 0;  // wpi is completely filled.
257  PushImage:
258         // Add this to mux->images_ list.
259         if (MuxImagePush(wpi, &mux->images_) != WEBP_MUX_OK) goto Err;
260         MuxImageInit(wpi);  // Reset for reading next image.
261         break;
262       case WEBP_CHUNK_ANMF:
263         if (wpi->is_partial_) goto Err;  // Previous wpi is still incomplete.
264         if (!MuxImageParse(&chunk, copy_data, wpi)) goto Err;
265         ChunkRelease(&chunk);
266         goto PushImage;
267         break;
268       default:  // A non-image chunk.
269         if (wpi->is_partial_) goto Err;  // Encountered a non-image chunk before
270                                          // getting all chunks of an image.
271         if (chunk_list_ends[id] == NULL) {
272           chunk_list_ends[id] =
273               MuxGetChunkListFromId(mux, id);  // List to add this chunk.
274         }
275         if (ChunkAppend(&chunk, &chunk_list_ends[id]) != WEBP_MUX_OK) goto Err;
276         if (id == WEBP_CHUNK_VP8X) {  // grab global specs
277           if (data_size < CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE) goto Err;
278           mux->canvas_width_ = GetLE24(data + 12) + 1;
279           mux->canvas_height_ = GetLE24(data + 15) + 1;
280         }
281         break;
282     }
283     data += data_size;
284     size -= data_size;
285     ChunkInit(&chunk);
286   }
287 
288   // Incomplete image.
289   if (wpi->is_partial_) goto Err;
290 
291   // Validate mux if complete.
292   if (MuxValidate(mux) != WEBP_MUX_OK) goto Err;
293 
294   MuxImageDelete(wpi);
295   return mux;  // All OK;
296 
297  Err:  // Something bad happened.
298   ChunkRelease(&chunk);
299   MuxImageDelete(wpi);
300   WebPMuxDelete(mux);
301   return NULL;
302 }
303 
304 //------------------------------------------------------------------------------
305 // Get API(s).
306 
307 // Validates that the given mux has a single image.
ValidateForSingleImage(const WebPMux * const mux)308 static WebPMuxError ValidateForSingleImage(const WebPMux* const mux) {
309   const int num_images = MuxImageCount(mux->images_, WEBP_CHUNK_IMAGE);
310   const int num_frames = MuxImageCount(mux->images_, WEBP_CHUNK_ANMF);
311 
312   if (num_images == 0) {
313     // No images in mux.
314     return WEBP_MUX_NOT_FOUND;
315   } else if (num_images == 1 && num_frames == 0) {
316     // Valid case (single image).
317     return WEBP_MUX_OK;
318   } else {
319     // Frame case OR an invalid mux.
320     return WEBP_MUX_INVALID_ARGUMENT;
321   }
322 }
323 
324 // Get the canvas width, height and flags after validating that VP8X/VP8/VP8L
325 // chunk and canvas size are valid.
MuxGetCanvasInfo(const WebPMux * const mux,int * width,int * height,uint32_t * flags)326 static WebPMuxError MuxGetCanvasInfo(const WebPMux* const mux,
327                                      int* width, int* height, uint32_t* flags) {
328   int w, h;
329   uint32_t f = 0;
330   WebPData data;
331   assert(mux != NULL);
332 
333   // Check if VP8X chunk is present.
334   if (MuxGet(mux, IDX_VP8X, 1, &data) == WEBP_MUX_OK) {
335     if (data.size < VP8X_CHUNK_SIZE) return WEBP_MUX_BAD_DATA;
336     f = GetLE32(data.bytes + 0);
337     w = GetLE24(data.bytes + 4) + 1;
338     h = GetLE24(data.bytes + 7) + 1;
339   } else {
340     const WebPMuxImage* const wpi = mux->images_;
341     // Grab user-forced canvas size as default.
342     w = mux->canvas_width_;
343     h = mux->canvas_height_;
344     if (w == 0 && h == 0 && ValidateForSingleImage(mux) == WEBP_MUX_OK) {
345       // single image and not forced canvas size => use dimension of first frame
346       assert(wpi != NULL);
347       w = wpi->width_;
348       h = wpi->height_;
349     }
350     if (wpi != NULL) {
351       if (wpi->has_alpha_) f |= ALPHA_FLAG;
352     }
353   }
354   if (w * (uint64_t)h >= MAX_IMAGE_AREA) return WEBP_MUX_BAD_DATA;
355 
356   if (width != NULL) *width = w;
357   if (height != NULL) *height = h;
358   if (flags != NULL) *flags = f;
359   return WEBP_MUX_OK;
360 }
361 
WebPMuxGetCanvasSize(const WebPMux * mux,int * width,int * height)362 WebPMuxError WebPMuxGetCanvasSize(const WebPMux* mux, int* width, int* height) {
363   if (mux == NULL || width == NULL || height == NULL) {
364     return WEBP_MUX_INVALID_ARGUMENT;
365   }
366   return MuxGetCanvasInfo(mux, width, height, NULL);
367 }
368 
WebPMuxGetFeatures(const WebPMux * mux,uint32_t * flags)369 WebPMuxError WebPMuxGetFeatures(const WebPMux* mux, uint32_t* flags) {
370   if (mux == NULL || flags == NULL) return WEBP_MUX_INVALID_ARGUMENT;
371   return MuxGetCanvasInfo(mux, NULL, NULL, flags);
372 }
373 
EmitVP8XChunk(uint8_t * const dst,int width,int height,uint32_t flags)374 static uint8_t* EmitVP8XChunk(uint8_t* const dst, int width,
375                               int height, uint32_t flags) {
376   const size_t vp8x_size = CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE;
377   assert(width >= 1 && height >= 1);
378   assert(width <= MAX_CANVAS_SIZE && height <= MAX_CANVAS_SIZE);
379   assert(width * (uint64_t)height < MAX_IMAGE_AREA);
380   PutLE32(dst, MKFOURCC('V', 'P', '8', 'X'));
381   PutLE32(dst + TAG_SIZE, VP8X_CHUNK_SIZE);
382   PutLE32(dst + CHUNK_HEADER_SIZE, flags);
383   PutLE24(dst + CHUNK_HEADER_SIZE + 4, width - 1);
384   PutLE24(dst + CHUNK_HEADER_SIZE + 7, height - 1);
385   return dst + vp8x_size;
386 }
387 
388 // Assemble a single image WebP bitstream from 'wpi'.
SynthesizeBitstream(const WebPMuxImage * const wpi,WebPData * const bitstream)389 static WebPMuxError SynthesizeBitstream(const WebPMuxImage* const wpi,
390                                         WebPData* const bitstream) {
391   uint8_t* dst;
392 
393   // Allocate data.
394   const int need_vp8x = (wpi->alpha_ != NULL);
395   const size_t vp8x_size = need_vp8x ? CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE : 0;
396   const size_t alpha_size = need_vp8x ? ChunkDiskSize(wpi->alpha_) : 0;
397   // Note: No need to output ANMF chunk for a single image.
398   const size_t size = RIFF_HEADER_SIZE + vp8x_size + alpha_size +
399                       ChunkDiskSize(wpi->img_);
400   uint8_t* const data = (uint8_t*)WebPSafeMalloc(1ULL, size);
401   if (data == NULL) return WEBP_MUX_MEMORY_ERROR;
402 
403   // There should be at most one alpha_ chunk and exactly one img_ chunk.
404   assert(wpi->alpha_ == NULL || wpi->alpha_->next_ == NULL);
405   assert(wpi->img_ != NULL && wpi->img_->next_ == NULL);
406 
407   // Main RIFF header.
408   dst = MuxEmitRiffHeader(data, size);
409 
410   if (need_vp8x) {
411     dst = EmitVP8XChunk(dst, wpi->width_, wpi->height_, ALPHA_FLAG);  // VP8X.
412     dst = ChunkListEmit(wpi->alpha_, dst);       // ALPH.
413   }
414 
415   // Bitstream.
416   dst = ChunkListEmit(wpi->img_, dst);
417   assert(dst == data + size);
418 
419   // Output.
420   bitstream->bytes = data;
421   bitstream->size = size;
422   return WEBP_MUX_OK;
423 }
424 
WebPMuxGetChunk(const WebPMux * mux,const char fourcc[4],WebPData * chunk_data)425 WebPMuxError WebPMuxGetChunk(const WebPMux* mux, const char fourcc[4],
426                              WebPData* chunk_data) {
427   CHUNK_INDEX idx;
428   if (mux == NULL || fourcc == NULL || chunk_data == NULL) {
429     return WEBP_MUX_INVALID_ARGUMENT;
430   }
431   idx = ChunkGetIndexFromFourCC(fourcc);
432   if (IsWPI(kChunks[idx].id)) {     // An image chunk.
433     return WEBP_MUX_INVALID_ARGUMENT;
434   } else if (idx != IDX_UNKNOWN) {  // A known chunk type.
435     return MuxGet(mux, idx, 1, chunk_data);
436   } else {                          // An unknown chunk type.
437     const WebPChunk* const chunk =
438         ChunkSearchList(mux->unknown_, 1, ChunkGetTagFromFourCC(fourcc));
439     if (chunk == NULL) return WEBP_MUX_NOT_FOUND;
440     *chunk_data = chunk->data_;
441     return WEBP_MUX_OK;
442   }
443 }
444 
MuxGetImageInternal(const WebPMuxImage * const wpi,WebPMuxFrameInfo * const info)445 static WebPMuxError MuxGetImageInternal(const WebPMuxImage* const wpi,
446                                         WebPMuxFrameInfo* const info) {
447   // Set some defaults for unrelated fields.
448   info->x_offset = 0;
449   info->y_offset = 0;
450   info->duration = 1;
451   info->dispose_method = WEBP_MUX_DISPOSE_NONE;
452   info->blend_method = WEBP_MUX_BLEND;
453   // Extract data for related fields.
454   info->id = ChunkGetIdFromTag(wpi->img_->tag_);
455   return SynthesizeBitstream(wpi, &info->bitstream);
456 }
457 
MuxGetFrameInternal(const WebPMuxImage * const wpi,WebPMuxFrameInfo * const frame)458 static WebPMuxError MuxGetFrameInternal(const WebPMuxImage* const wpi,
459                                         WebPMuxFrameInfo* const frame) {
460   const int is_frame = (wpi->header_->tag_ == kChunks[IDX_ANMF].tag);
461   const WebPData* frame_data;
462   if (!is_frame) return WEBP_MUX_INVALID_ARGUMENT;
463   assert(wpi->header_ != NULL);  // Already checked by WebPMuxGetFrame().
464   // Get frame chunk.
465   frame_data = &wpi->header_->data_;
466   if (frame_data->size < kChunks[IDX_ANMF].size) return WEBP_MUX_BAD_DATA;
467   // Extract info.
468   frame->x_offset = 2 * GetLE24(frame_data->bytes + 0);
469   frame->y_offset = 2 * GetLE24(frame_data->bytes + 3);
470   {
471     const uint8_t bits = frame_data->bytes[15];
472     frame->duration = GetLE24(frame_data->bytes + 12);
473     frame->dispose_method =
474         (bits & 1) ? WEBP_MUX_DISPOSE_BACKGROUND : WEBP_MUX_DISPOSE_NONE;
475     frame->blend_method = (bits & 2) ? WEBP_MUX_NO_BLEND : WEBP_MUX_BLEND;
476   }
477   frame->id = ChunkGetIdFromTag(wpi->header_->tag_);
478   return SynthesizeBitstream(wpi, &frame->bitstream);
479 }
480 
WebPMuxGetFrame(const WebPMux * mux,uint32_t nth,WebPMuxFrameInfo * frame)481 WebPMuxError WebPMuxGetFrame(
482     const WebPMux* mux, uint32_t nth, WebPMuxFrameInfo* frame) {
483   WebPMuxError err;
484   WebPMuxImage* wpi;
485 
486   // Sanity checks.
487   if (mux == NULL || frame == NULL) {
488     return WEBP_MUX_INVALID_ARGUMENT;
489   }
490 
491   // Get the nth WebPMuxImage.
492   err = MuxImageGetNth((const WebPMuxImage**)&mux->images_, nth, &wpi);
493   if (err != WEBP_MUX_OK) return err;
494 
495   // Get frame info.
496   if (wpi->header_ == NULL) {
497     return MuxGetImageInternal(wpi, frame);
498   } else {
499     return MuxGetFrameInternal(wpi, frame);
500   }
501 }
502 
WebPMuxGetAnimationParams(const WebPMux * mux,WebPMuxAnimParams * params)503 WebPMuxError WebPMuxGetAnimationParams(const WebPMux* mux,
504                                        WebPMuxAnimParams* params) {
505   WebPData anim;
506   WebPMuxError err;
507 
508   if (mux == NULL || params == NULL) return WEBP_MUX_INVALID_ARGUMENT;
509 
510   err = MuxGet(mux, IDX_ANIM, 1, &anim);
511   if (err != WEBP_MUX_OK) return err;
512   if (anim.size < kChunks[WEBP_CHUNK_ANIM].size) return WEBP_MUX_BAD_DATA;
513   params->bgcolor = GetLE32(anim.bytes);
514   params->loop_count = GetLE16(anim.bytes + 4);
515 
516   return WEBP_MUX_OK;
517 }
518 
519 // Get chunk index from chunk id. Returns IDX_NIL if not found.
ChunkGetIndexFromId(WebPChunkId id)520 static CHUNK_INDEX ChunkGetIndexFromId(WebPChunkId id) {
521   int i;
522   for (i = 0; kChunks[i].id != WEBP_CHUNK_NIL; ++i) {
523     if (id == kChunks[i].id) return (CHUNK_INDEX)i;
524   }
525   return IDX_NIL;
526 }
527 
528 // Count number of chunks matching 'tag' in the 'chunk_list'.
529 // If tag == NIL_TAG, any tag will be matched.
CountChunks(const WebPChunk * const chunk_list,uint32_t tag)530 static int CountChunks(const WebPChunk* const chunk_list, uint32_t tag) {
531   int count = 0;
532   const WebPChunk* current;
533   for (current = chunk_list; current != NULL; current = current->next_) {
534     if (tag == NIL_TAG || current->tag_ == tag) {
535       count++;  // Count chunks whose tags match.
536     }
537   }
538   return count;
539 }
540 
WebPMuxNumChunks(const WebPMux * mux,WebPChunkId id,int * num_elements)541 WebPMuxError WebPMuxNumChunks(const WebPMux* mux,
542                               WebPChunkId id, int* num_elements) {
543   if (mux == NULL || num_elements == NULL) {
544     return WEBP_MUX_INVALID_ARGUMENT;
545   }
546 
547   if (IsWPI(id)) {
548     *num_elements = MuxImageCount(mux->images_, id);
549   } else {
550     WebPChunk* const* chunk_list = MuxGetChunkListFromId(mux, id);
551     const CHUNK_INDEX idx = ChunkGetIndexFromId(id);
552     *num_elements = CountChunks(*chunk_list, kChunks[idx].tag);
553   }
554 
555   return WEBP_MUX_OK;
556 }
557 
558 //------------------------------------------------------------------------------
559