read_image.h

Go to the documentation of this file.

/*
 * Copyright 2013 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http:///www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef PAGESPEED_KERNEL_IMAGE_READ_IMAGE_H_
#define PAGESPEED_KERNEL_IMAGE_READ_IMAGE_H_

#include <cstddef>
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/image/image_util.h"
#include "pagespeed/kernel/image/scanline_status.h"

namespace net_instaweb {
class MessageHandler;
}

namespace pagespeed {

namespace image_compression {

class MultipleFrameReader;
class MultipleFrameWriter;
class ScanlineReaderInterface;
class ScanlineWriterInterface;

using net_instaweb::MessageHandler;
using pagespeed::image_compression::QuirksMode;
using pagespeed::image_compression::QUIRKS_CHROME;



ScanlineReaderInterface* CreateScanlineReader(ImageFormat image_type,
                                              const void* image_buffer,
                                              size_t buffer_length,
                                              MessageHandler* handler,
                                              ScanlineStatus* status);

inline ScanlineReaderInterface* CreateScanlineReader(ImageFormat image_type,
                                                     const void* image_buffer,
                                                     size_t buffer_length,
                                                     MessageHandler* handler) {
  ScanlineStatus status;
  return CreateScanlineReader(image_type, image_buffer, buffer_length,
                              handler, &status);
}

ScanlineWriterInterface* CreateScanlineWriter(
    ImageFormat image_type,     
    PixelFormat pixel_format,   
    size_t width,               
    size_t height,              
    const void* config,         
    GoogleString* image_data,   
    MessageHandler* handler,    
    ScanlineStatus* status); 

inline ScanlineWriterInterface* CreateScanlineWriter(ImageFormat image_type,
                                                     PixelFormat pixel_format,
                                                     size_t width,
                                                     size_t height,
                                                     const void* config,
                                                     GoogleString* image_data,
                                                     MessageHandler* handler) {
  ScanlineStatus status;
  return CreateScanlineWriter(image_type, pixel_format, width, height,
                              config, image_data, handler, &status);
}


MultipleFrameReader* CreateImageFrameReader(
    ImageFormat image_type,
    const void* image_buffer,
    size_t buffer_length,
    QuirksMode quirks_mode,
    MessageHandler* handler,
    ScanlineStatus* status);

inline MultipleFrameReader* CreateImageFrameReader(
    ImageFormat image_type,
    const void* image_buffer,
    size_t buffer_length,
    MessageHandler* handler,
    ScanlineStatus* status) {
  return CreateImageFrameReader(image_type, image_buffer, buffer_length,
                                QUIRKS_CHROME, handler, status);
}

MultipleFrameWriter* CreateImageFrameWriter(
    ImageFormat image_type,     
    const void* config,         
    GoogleString* image_data,   
    MessageHandler* handler,    
    ScanlineStatus* status); 


bool ReadImage(ImageFormat image_type,
               const void* image_buffer,
               size_t buffer_length,
               void** pixels,
               PixelFormat* pixel_format,
               size_t* width,
               size_t* height,
               size_t* stride,
               MessageHandler* handler);

}  

}  

#endif