1 /*

     2  * This file is part of Libav.

     3  *

     4  * Libav is free software; you can redistribute it and/or

     5  * modify it under the terms of the GNU Lesser General Public

     6  * License as published by the Free Software Foundation; either

     7  * version 2.1 of the License, or (at your option) any later version.

     8  *

     9  * Libav is distributed in the hope that it will be useful,

    10  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    12  * Lesser General Public License for more details.

    13  *

    14  * You should have received a copy of the GNU Lesser General Public

    15  * License along with Libav; if not, write to the Free Software

    16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

    17  */

    18 

    19 #ifndef AVUTIL_IMGUTILS_H

    20 #define AVUTIL_IMGUTILS_H

    21 

    22 /**

    23  * @file

    24  * misc image utilities

    25  *

    26  * @addtogroup lavu_picture

    27  * @{

    28  */

    29 

    30 #include "avutil.h"

    31 #include "pixdesc.h"

    32 

    33 /**

    34  * Compute the max pixel step for each plane of an image with a

    35  * format described by pixdesc.

    36  *

    37  * The pixel step is the distance in bytes between the first byte of

    38  * the group of bytes which describe a pixel component and the first

    39  * byte of the successive group in the same plane for the same

    40  * component.

    41  *

    42  * @param max_pixsteps an array which is filled with the max pixel step

    43  * for each plane. Since a plane may contain different pixel

    44  * components, the computed max_pixsteps[plane] is relative to the

    45  * component in the plane with the max pixel step.

    46  * @param max_pixstep_comps an array which is filled with the component

    47  * for each plane which has the max pixel step. May be NULL.

    48  */

    49 void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4],

    50                                 const AVPixFmtDescriptor *pixdesc);

    51 

    52 /**

    53  * Compute the size of an image line with format pix_fmt and width

    54  * width for the plane plane.

    55  *

    56  * @return the computed size in bytes

    57  */

    58 int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane);

    59 

    60 /**

    61  * Fill plane linesizes for an image with pixel format pix_fmt and

    62  * width width.

    63  *

    64  * @param linesizes array to be filled with the linesize for each plane

    65  * @return >= 0 in case of success, a negative error code otherwise

    66  */

    67 int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width);

    68 

    69 /**

    70  * Fill plane data pointers for an image with pixel format pix_fmt and

    71  * height height.

    72  *

    73  * @param data pointers array to be filled with the pointer for each image plane

    74  * @param ptr the pointer to a buffer which will contain the image

    75  * @param linesizes the array containing the linesize for each

    76  * plane, should be filled by av_image_fill_linesizes()

    77  * @return the size in bytes required for the image buffer, a negative

    78  * error code in case of failure

    79  */

    80 int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int height,

    81                            uint8_t *ptr, const int linesizes[4]);

    82 

    83 /**

    84  * Allocate an image with size w and h and pixel format pix_fmt, and

    85  * fill pointers and linesizes accordingly.

    86  * The allocated image buffer has to be freed by using

    87  * av_freep(&pointers[0]).

    88  *

    89  * @param align the value to use for buffer size alignment

    90  * @return the size in bytes required for the image buffer, a negative

    91  * error code in case of failure

    92  */

    93 int av_image_alloc(uint8_t *pointers[4], int linesizes[4],

    94                    int w, int h, enum AVPixelFormat pix_fmt, int align);

    95 

    96 /**

    97  * Copy image plane from src to dst.

    98  * That is, copy "height" number of lines of "bytewidth" bytes each.

    99  * The first byte of each successive line is separated by *_linesize

   100  * bytes.

   101  *

   102  * @param dst_linesize linesize for the image plane in dst

   103  * @param src_linesize linesize for the image plane in src

   104  */

   105 void av_image_copy_plane(uint8_t       *dst, int dst_linesize,

   106                          const uint8_t *src, int src_linesize,

   107                          int bytewidth, int height);

   108 

   109 /**

   110  * Copy image in src_data to dst_data.

   111  *

   112  * @param dst_linesizes linesizes for the image in dst_data

   113  * @param src_linesizes linesizes for the image in src_data

   114  */

   115 void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],

   116                    const uint8_t *src_data[4], const int src_linesizes[4],

   117                    enum AVPixelFormat pix_fmt, int width, int height);

   118 

   119 /**

   120  * Check if the given dimension of an image is valid, meaning that all

   121  * bytes of the image can be addressed with a signed int.

   122  *

   123  * @param w the width of the picture

   124  * @param h the height of the picture

   125  * @param log_offset the offset to sum to the log level for logging with log_ctx

   126  * @param log_ctx the parent logging context, it may be NULL

   127  * @return >= 0 if valid, a negative error code otherwise

   128  */

   129 int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx);

   130 

   131 int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt);

   132 

   133 /**

   134  * @}

   135  */

   136 

   137 

   138 #endif /* AVUTIL_IMGUTILS_H */