libwebp: upstream animation cherry-picks

third_party/libwebp/demux/demux.c

 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  WebP container demux.
@@ skipping 29 matching lines @@
 } MemBuffer;
 
 typedef struct {
   size_t offset_;
   size_t size_;
 } ChunkData;
 
 typedef struct Frame {
   int x_offset_, y_offset_;
   int width_, height_;
+  int has_alpha_;
   int duration_;
   WebPMuxAnimDispose dispose_method_;
+  WebPMuxAnimBlend blend_method_;
   int is_fragment_;  // this is a frame fragment (and not a full frame).
   int frame_num_;  // the referent frame number for use in assembling fragments.
   int complete_;   // img_components_ contains a full image.
   ChunkData img_components_[2];  // 0=VP8{,L} 1=ALPH
   struct Frame* next_;
 } Frame;
 
 typedef struct Chunk {
   ChunkData data_;
   struct Chunk* next_;
@@ skipping 127 matching lines @@
   const Frame* const last_frame = *dmux->frames_tail_;
   if (last_frame != NULL && !last_frame->complete_) return 0;
 
   *dmux->frames_tail_ = frame;
   frame->next_ = NULL;
   dmux->frames_tail_ = &frame->next_;
   return 1;
 }
 
 // Store image bearing chunks to 'frame'.
-// If 'has_vp8l_alpha' is not NULL, it will be set to true if the frame is a
-// lossless image with alpha.
 static ParseStatus StoreFrame(int frame_num, uint32_t min_size,
-                              MemBuffer* const mem, Frame* const frame,
-                              int* const has_vp8l_alpha) {
+                              MemBuffer* const mem, Frame* const frame) {
   int alpha_chunks = 0;
   int image_chunks = 0;
   int done = (MemDataSize(mem) < min_size);
   ParseStatus status = PARSE_OK;
 
-  if (has_vp8l_alpha != NULL) *has_vp8l_alpha = 0;  // Default.
-
   if (done) return PARSE_NEED_MORE_DATA;
 
   do {
     const size_t chunk_start_offset = mem->start_;
     const uint32_t fourcc = ReadLE32(mem);
     const uint32_t payload_size = ReadLE32(mem);
     const uint32_t payload_size_padded = payload_size + (payload_size & 1);
     const size_t payload_available = (payload_size_padded > MemDataSize(mem))
                                    ? MemDataSize(mem) : payload_size_padded;
     const size_t chunk_size = CHUNK_HEADER_SIZE + payload_available;
 
     if (payload_size > MAX_CHUNK_PAYLOAD) return PARSE_ERROR;
     if (SizeIsInvalid(mem, payload_size_padded)) return PARSE_ERROR;
     if (payload_size_padded > MemDataSize(mem)) status = PARSE_NEED_MORE_DATA;
 
     switch (fourcc) {
       case MKFOURCC('A', 'L', 'P', 'H'):
         if (alpha_chunks == 0) {
           ++alpha_chunks;
           frame->img_components_[1].offset_ = chunk_start_offset;
           frame->img_components_[1].size_ = chunk_size;
+          frame->has_alpha_ = 1;
           frame->frame_num_ = frame_num;
           Skip(mem, payload_available);
         } else {
           goto Done;
         }
         break;
       case MKFOURCC('V', 'P', '8', 'L'):
         if (alpha_chunks > 0) return PARSE_ERROR;  // VP8L has its own alpha
         // fall through
       case MKFOURCC('V', 'P', '8', ' '):
         if (image_chunks == 0) {
           // Extract the bitstream features, tolerating failures when the data
           // is incomplete.
           WebPBitstreamFeatures features;
           const VP8StatusCode vp8_status =
               WebPGetFeatures(mem->buf_ + chunk_start_offset, chunk_size,
                               &features);
           if (status == PARSE_NEED_MORE_DATA &&
               vp8_status == VP8_STATUS_NOT_ENOUGH_DATA) {
             return PARSE_NEED_MORE_DATA;
           } else if (vp8_status != VP8_STATUS_OK) {
             // We have enough data, and yet WebPGetFeatures() failed.
             return PARSE_ERROR;
           }
           ++image_chunks;
           frame->img_components_[0].offset_ = chunk_start_offset;
           frame->img_components_[0].size_ = chunk_size;
           frame->width_ = features.width;
           frame->height_ = features.height;
-          if (has_vp8l_alpha != NULL) *has_vp8l_alpha = features.has_alpha;
+          frame->has_alpha_ |= features.has_alpha;

[fbarchard, 2013/08/21 02:00:13]

if you dont check the pointer, to enable alpha, theres a risk that the user may
pass a null by accident?  May want to check the pointer as well.

[urvang (Google), 2013/08/21 02:16:51]

Nope. StoreFrame() is a static method, so 'frame' is always non-null here.

           frame->frame_num_ = frame_num;
           frame->complete_ = (status == PARSE_OK);
           Skip(mem, payload_available);
         } else {
           goto Done;
         }
         break;
  Done:
       default:
         // Restore fourcc/size when moving up one level in parsing.
@@ skipping 27 matching lines @@
   return (*frame == NULL) ? PARSE_ERROR : PARSE_OK;
 }
 
 // Parse a 'ANMF' chunk and any image bearing chunks that immediately follow.
 // 'frame_chunk_size' is the previously validated, padded chunk size.
 static ParseStatus ParseAnimationFrame(
     WebPDemuxer* const dmux, uint32_t frame_chunk_size) {
   const int has_frames = !!(dmux->feature_flags_ & ANIMATION_FLAG);
   const uint32_t anmf_payload_size = frame_chunk_size - ANMF_CHUNK_SIZE;
   int added_frame = 0;
+  int bits;
   MemBuffer* const mem = &dmux->mem_;
   Frame* frame;
   ParseStatus status =
       NewFrame(mem, ANMF_CHUNK_SIZE, frame_chunk_size, &frame);
   if (status != PARSE_OK) return status;
 
   frame->x_offset_       = 2 * ReadLE24s(mem);
   frame->y_offset_       = 2 * ReadLE24s(mem);
   frame->width_          = 1 + ReadLE24s(mem);
   frame->height_         = 1 + ReadLE24s(mem);
   frame->duration_       = ReadLE24s(mem);
-  frame->dispose_method_ = (WebPMuxAnimDispose)(ReadByte(mem) & 1);
+  bits = ReadByte(mem);
+  frame->dispose_method_ =
+      (bits & 1) ? WEBP_MUX_DISPOSE_BACKGROUND : WEBP_MUX_DISPOSE_NONE;
+  frame->blend_method_ = (bits & 2) ? WEBP_MUX_NO_BLEND : WEBP_MUX_BLEND;
   if (frame->width_ * (uint64_t)frame->height_ >= MAX_IMAGE_AREA) {
     free(frame);
     return PARSE_ERROR;
   }
 
   // Store a frame only if the animation flag is set there is some data for
   // this frame is available.
-  status = StoreFrame(dmux->num_frames_ + 1, anmf_payload_size, mem, frame,
-                      NULL);
+  status = StoreFrame(dmux->num_frames_ + 1, anmf_payload_size, mem, frame);
   if (status != PARSE_ERROR && has_frames && frame->frame_num_ > 0) {
     added_frame = AddFrame(dmux, frame);
     if (added_frame) {
       ++dmux->num_frames_;
     } else {
       status = PARSE_ERROR;
     }
   }
 
   if (!added_frame) free(frame);
@@ skipping 14 matching lines @@
   ParseStatus status =
       NewFrame(mem, FRGM_CHUNK_SIZE, fragment_chunk_size, &frame);
   if (status != PARSE_OK) return status;
 
   frame->is_fragment_ = 1;
   frame->x_offset_ = 2 * ReadLE24s(mem);
   frame->y_offset_ = 2 * ReadLE24s(mem);
 
   // Store a fragment only if the fragments flag is set there is some data for
   // this fragment is available.
-  status = StoreFrame(frame_num, frgm_payload_size, mem, frame, NULL);
+  status = StoreFrame(frame_num, frgm_payload_size, mem, frame);
   if (status != PARSE_ERROR && has_fragments && frame->frame_num_ > 0) {
     added_fragment = AddFrame(dmux, frame);
     if (!added_fragment) {
       status = PARSE_ERROR;
     } else {
       dmux->num_frames_ = 1;
     }
   }
 
   if (!added_fragment) free(frame);
@@ skipping 42 matching lines @@
 
   Skip(mem, RIFF_HEADER_SIZE);
   return 1;
 }
 
 static ParseStatus ParseSingleImage(WebPDemuxer* const dmux) {
   const size_t min_size = CHUNK_HEADER_SIZE;
   MemBuffer* const mem = &dmux->mem_;
   Frame* frame;
   ParseStatus status;
-  int has_vp8l_alpha = 0;  // Frame contains a lossless image with alpha.
 
   if (dmux->frames_ != NULL) return PARSE_ERROR;
   if (SizeIsInvalid(mem, min_size)) return PARSE_ERROR;
   if (MemDataSize(mem) < min_size) return PARSE_NEED_MORE_DATA;
 
   frame = (Frame*)calloc(1, sizeof(*frame));
   if (frame == NULL) return PARSE_ERROR;
 
   // For the single image case we allow parsing of a partial frame, but we need
   // at least CHUNK_HEADER_SIZE for parsing.
-  status = StoreFrame(1, CHUNK_HEADER_SIZE, &dmux->mem_, frame,
-                      &has_vp8l_alpha);
+  status = StoreFrame(1, CHUNK_HEADER_SIZE, &dmux->mem_, frame);
   if (status != PARSE_ERROR) {
     const int has_alpha = !!(dmux->feature_flags_ & ALPHA_FLAG);
     // Clear any alpha when the alpha flag is missing.
     if (!has_alpha && frame->img_components_[1].size_ > 0) {
       frame->img_components_[1].offset_ = 0;
       frame->img_components_[1].size_ = 0;
+      frame->has_alpha_ = 0;
     }
 
     // Use the frame width/height as the canvas values for non-vp8x files.
     // Also, set ALPHA_FLAG if this is a lossless image with alpha.
     if (!dmux->is_ext_format_ && frame->width_ > 0 && frame->height_ > 0) {
       dmux->state_ = WEBP_DEMUX_PARSED_HEADER;
       dmux->canvas_width_ = frame->width_;
       dmux->canvas_height_ = frame->height_;
-      dmux->feature_flags_ |= has_vp8l_alpha ? ALPHA_FLAG : 0;
+      dmux->feature_flags_ |= frame->has_alpha_ ? ALPHA_FLAG : 0;
     }
     AddFrame(dmux, frame);
     dmux->num_frames_ = 1;
   } else {
     free(frame);
   }
 
   return status;
 }
 
@@ skipping 364 matching lines @@
   assert(first_frame != NULL);
 
   iter->frame_num      = first_frame->frame_num_;
   iter->num_frames     = dmux->num_frames_;
   iter->fragment_num   = fragment_num;
   iter->num_fragments  = num_fragments;
   iter->x_offset       = fragment->x_offset_;
   iter->y_offset       = fragment->y_offset_;
   iter->width          = fragment->width_;
   iter->height         = fragment->height_;
+  iter->has_alpha      = fragment->has_alpha_;
   iter->duration       = fragment->duration_;
   iter->dispose_method = fragment->dispose_method_;
+  iter->blend_method   = fragment->blend_method_;
   iter->complete       = fragment->complete_;
   iter->fragment.bytes = payload;
   iter->fragment.size  = payload_size;
   // TODO(jzern): adjust offsets for 'FRGM's embedded in 'ANMF's
   return 1;
 }
 
 static int SetFrame(int frame_num, WebPIterator* const iter) {
   const Frame* frame;
   const WebPDemuxer* const dmux = (WebPDemuxer*)iter->private_;
@@ skipping 118 matching lines @@
   return 0;
 }
 
 void WebPDemuxReleaseChunkIterator(WebPChunkIterator* iter) {
   (void)iter;
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }  // extern "C"
 #endif