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 */ |
|