Mercurial > libavcodec.hg
annotate imgconvert.c @ 12454:f4355cd85faa libavcodec
Port latest x264 deblock asm (before they moved to using NV12 as internal
format), LGPL'ed with permission from Jason and Loren. This includes mmx2
code, so remove inline asm from h264dsp_mmx.c accordingly.
author | rbultje |
---|---|
date | Fri, 03 Sep 2010 16:52:46 +0000 |
parents | e05e29a04ada |
children | ffb3668ff7af |
rev | line source |
---|---|
0 | 1 /* |
5355 | 2 * Misc image conversion routines |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8601
diff
changeset
|
3 * Copyright (c) 2001, 2002, 2003 Fabrice Bellard |
0 | 4 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3646
diff
changeset
|
5 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3646
diff
changeset
|
6 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3646
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
429 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3646
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
0 | 11 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3646
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
0 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 * Lesser General Public License for more details. | |
0 | 16 * |
429 | 17 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3646
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2979
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 20 */ |
1106 | 21 |
22 /** | |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11630
diff
changeset
|
23 * @file |
5355 | 24 * misc image conversion routines |
1106 | 25 */ |
26 | |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
27 /* TODO: |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
28 * - write 'ffimg' program to test all the image related stuff |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
29 * - move all api to slice based system |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
30 * - integrate deinterlacing, postprocessing and scaling in the conversion process |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
31 */ |
1106 | 32 |
0 | 33 #include "avcodec.h" |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
34 #include "dsputil.h" |
11318
ad0ea9f21f9a
Include internal.h and imgconvert.h, they contain the prototypes for the
cehoyos
parents:
11059
diff
changeset
|
35 #include "internal.h" |
ad0ea9f21f9a
Include internal.h and imgconvert.h, they contain the prototypes for the
cehoyos
parents:
11059
diff
changeset
|
36 #include "imgconvert.h" |
12039 | 37 #include "libavutil/colorspace.h" |
10572
a21b640dba50
Use av_pix_fmt_descriptors in ff_is_hwaccel_pix_fmt() rather than
stefano
parents:
10569
diff
changeset
|
38 #include "libavutil/pixdesc.h" |
12298
bfc36c0fea55
Move fill_image_linesize() and fill_image_data_ptr() from
stefano
parents:
12277
diff
changeset
|
39 #include "libavcore/imgutils.h" |
0 | 40 |
12317 | 41 #if HAVE_MMX && HAVE_YASM |
8430 | 42 #include "x86/dsputil_mmx.h" |
801 | 43 #endif |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
44 |
1204 | 45 #define xglue(x, y) x ## y |
46 #define glue(x, y) xglue(x, y) | |
47 | |
4549 | 48 #define FF_COLOR_RGB 0 /**< RGB color space */ |
49 #define FF_COLOR_GRAY 1 /**< gray color space */ | |
50 #define FF_COLOR_YUV 2 /**< YUV color space. 16 <= Y <= 235, 16 <= U, V <= 240 */ | |
51 #define FF_COLOR_YUV_JPEG 3 /**< YUV color space. 0 <= Y <= 255, 0 <= U, V <= 255 */ | |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
52 |
4549 | 53 #define FF_PIXEL_PLANAR 0 /**< each channel has one component in AVPicture */ |
54 #define FF_PIXEL_PACKED 1 /**< only one components containing all the channels */ | |
55 #define FF_PIXEL_PALETTE 2 /**< one components containing indexes for a palette */ | |
1204 | 56 |
12317 | 57 #if HAVE_MMX && HAVE_YASM |
12316 | 58 #define deinterlace_line_inplace ff_deinterlace_line_inplace_mmx |
59 #define deinterlace_line ff_deinterlace_line_mmx | |
60 #else | |
61 #define deinterlace_line_inplace deinterlace_line_inplace_c | |
62 #define deinterlace_line deinterlace_line_c | |
63 #endif | |
64 | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
65 typedef struct PixFmtInfo { |
4549 | 66 uint8_t nb_channels; /**< number of channels (including alpha) */ |
67 uint8_t color_type; /**< color type (see FF_COLOR_xxx constants) */ | |
68 uint8_t pixel_type; /**< pixel storage type (see FF_PIXEL_xxx constants) */ | |
69 uint8_t is_alpha : 1; /**< true if alpha can be specified */ | |
70 uint8_t depth; /**< bit depth of the color components */ | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
71 } PixFmtInfo; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
72 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
73 /* this table gives more information about formats */ |
3420 | 74 static const PixFmtInfo pix_fmt_info[PIX_FMT_NB] = { |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
75 /* YUV formats */ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
76 [PIX_FMT_YUV420P] = { |
1204 | 77 .nb_channels = 3, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
78 .color_type = FF_COLOR_YUV, |
1204 | 79 .pixel_type = FF_PIXEL_PLANAR, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
80 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
81 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
82 [PIX_FMT_YUV422P] = { |
1204 | 83 .nb_channels = 3, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
84 .color_type = FF_COLOR_YUV, |
1204 | 85 .pixel_type = FF_PIXEL_PLANAR, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
86 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
87 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
88 [PIX_FMT_YUV444P] = { |
1204 | 89 .nb_channels = 3, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
90 .color_type = FF_COLOR_YUV, |
1204 | 91 .pixel_type = FF_PIXEL_PLANAR, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
92 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
93 }, |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
94 [PIX_FMT_YUYV422] = { |
1204 | 95 .nb_channels = 1, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
96 .color_type = FF_COLOR_YUV, |
1204 | 97 .pixel_type = FF_PIXEL_PACKED, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
98 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
99 }, |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
100 [PIX_FMT_UYVY422] = { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
101 .nb_channels = 1, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
102 .color_type = FF_COLOR_YUV, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
103 .pixel_type = FF_PIXEL_PACKED, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
104 .depth = 8, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
105 }, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
106 [PIX_FMT_YUV410P] = { |
1204 | 107 .nb_channels = 3, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
108 .color_type = FF_COLOR_YUV, |
1204 | 109 .pixel_type = FF_PIXEL_PLANAR, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
110 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
111 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
112 [PIX_FMT_YUV411P] = { |
1204 | 113 .nb_channels = 3, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
114 .color_type = FF_COLOR_YUV, |
1204 | 115 .pixel_type = FF_PIXEL_PLANAR, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
116 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
117 }, |
5363 | 118 [PIX_FMT_YUV440P] = { |
119 .nb_channels = 3, | |
120 .color_type = FF_COLOR_YUV, | |
121 .pixel_type = FF_PIXEL_PLANAR, | |
122 .depth = 8, | |
123 }, | |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
124 [PIX_FMT_YUV420P16LE] = { |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
125 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
126 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
127 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
128 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
129 }, |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
130 [PIX_FMT_YUV422P16LE] = { |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
131 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
132 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
133 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
134 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
135 }, |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
136 [PIX_FMT_YUV444P16LE] = { |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
137 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
138 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
139 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
140 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
141 }, |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
142 [PIX_FMT_YUV420P16BE] = { |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
143 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
144 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
145 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
146 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
147 }, |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
148 [PIX_FMT_YUV422P16BE] = { |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
149 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
150 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
151 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
152 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
153 }, |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
154 [PIX_FMT_YUV444P16BE] = { |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
155 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
156 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
157 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
158 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
159 }, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
160 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
161 |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
162 /* YUV formats with alpha plane */ |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
163 [PIX_FMT_YUVA420P] = { |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
164 .nb_channels = 4, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
165 .color_type = FF_COLOR_YUV, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
166 .pixel_type = FF_PIXEL_PLANAR, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
167 .depth = 8, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
168 }, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
169 |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
170 /* JPEG YUV */ |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
171 [PIX_FMT_YUVJ420P] = { |
1204 | 172 .nb_channels = 3, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
173 .color_type = FF_COLOR_YUV_JPEG, |
1204 | 174 .pixel_type = FF_PIXEL_PLANAR, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
175 .depth = 8, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
176 }, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
177 [PIX_FMT_YUVJ422P] = { |
1204 | 178 .nb_channels = 3, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
179 .color_type = FF_COLOR_YUV_JPEG, |
1204 | 180 .pixel_type = FF_PIXEL_PLANAR, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
181 .depth = 8, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
182 }, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
183 [PIX_FMT_YUVJ444P] = { |
1204 | 184 .nb_channels = 3, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
185 .color_type = FF_COLOR_YUV_JPEG, |
1204 | 186 .pixel_type = FF_PIXEL_PLANAR, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
187 .depth = 8, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
188 }, |
5363 | 189 [PIX_FMT_YUVJ440P] = { |
190 .nb_channels = 3, | |
191 .color_type = FF_COLOR_YUV_JPEG, | |
192 .pixel_type = FF_PIXEL_PLANAR, | |
193 .depth = 8, | |
194 }, | |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
195 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
196 /* RGB formats */ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
197 [PIX_FMT_RGB24] = { |
1204 | 198 .nb_channels = 3, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
199 .color_type = FF_COLOR_RGB, |
1204 | 200 .pixel_type = FF_PIXEL_PACKED, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
201 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
202 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
203 [PIX_FMT_BGR24] = { |
1204 | 204 .nb_channels = 3, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
205 .color_type = FF_COLOR_RGB, |
1204 | 206 .pixel_type = FF_PIXEL_PACKED, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
207 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
208 }, |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
209 [PIX_FMT_ARGB] = { |
1204 | 210 .nb_channels = 4, .is_alpha = 1, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
211 .color_type = FF_COLOR_RGB, |
1204 | 212 .pixel_type = FF_PIXEL_PACKED, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
213 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
214 }, |
9001 | 215 [PIX_FMT_RGB48BE] = { |
216 .nb_channels = 3, | |
217 .color_type = FF_COLOR_RGB, | |
218 .pixel_type = FF_PIXEL_PACKED, | |
219 .depth = 16, | |
220 }, | |
221 [PIX_FMT_RGB48LE] = { | |
222 .nb_channels = 3, | |
223 .color_type = FF_COLOR_RGB, | |
224 .pixel_type = FF_PIXEL_PACKED, | |
225 .depth = 16, | |
226 }, | |
9223
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
227 [PIX_FMT_RGB565BE] = { |
1204 | 228 .nb_channels = 3, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
229 .color_type = FF_COLOR_RGB, |
1204 | 230 .pixel_type = FF_PIXEL_PACKED, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
231 .depth = 5, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
232 }, |
9223
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
233 [PIX_FMT_RGB565LE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
234 .nb_channels = 3, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
235 .color_type = FF_COLOR_RGB, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
236 .pixel_type = FF_PIXEL_PACKED, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
237 .depth = 5, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
238 }, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
239 [PIX_FMT_RGB555BE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
240 .nb_channels = 3, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
241 .color_type = FF_COLOR_RGB, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
242 .pixel_type = FF_PIXEL_PACKED, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
243 .depth = 5, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
244 }, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
245 [PIX_FMT_RGB555LE] = { |
4208 | 246 .nb_channels = 3, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
247 .color_type = FF_COLOR_RGB, |
1204 | 248 .pixel_type = FF_PIXEL_PACKED, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
249 .depth = 5, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
250 }, |
11366 | 251 [PIX_FMT_RGB444BE] = { |
252 .nb_channels = 3, | |
253 .color_type = FF_COLOR_RGB, | |
254 .pixel_type = FF_PIXEL_PACKED, | |
255 .depth = 4, | |
256 }, | |
257 [PIX_FMT_RGB444LE] = { | |
258 .nb_channels = 3, | |
259 .color_type = FF_COLOR_RGB, | |
260 .pixel_type = FF_PIXEL_PACKED, | |
261 .depth = 4, | |
262 }, | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
263 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
264 /* gray / mono formats */ |
4066 | 265 [PIX_FMT_GRAY16BE] = { |
266 .nb_channels = 1, | |
267 .color_type = FF_COLOR_GRAY, | |
268 .pixel_type = FF_PIXEL_PLANAR, | |
269 .depth = 16, | |
270 }, | |
271 [PIX_FMT_GRAY16LE] = { | |
272 .nb_channels = 1, | |
273 .color_type = FF_COLOR_GRAY, | |
274 .pixel_type = FF_PIXEL_PLANAR, | |
275 .depth = 16, | |
276 }, | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
277 [PIX_FMT_GRAY8] = { |
1204 | 278 .nb_channels = 1, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
279 .color_type = FF_COLOR_GRAY, |
1204 | 280 .pixel_type = FF_PIXEL_PLANAR, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
281 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
282 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
283 [PIX_FMT_MONOWHITE] = { |
1204 | 284 .nb_channels = 1, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
285 .color_type = FF_COLOR_GRAY, |
1204 | 286 .pixel_type = FF_PIXEL_PLANAR, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
287 .depth = 1, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
288 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
289 [PIX_FMT_MONOBLACK] = { |
1204 | 290 .nb_channels = 1, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
291 .color_type = FF_COLOR_GRAY, |
1204 | 292 .pixel_type = FF_PIXEL_PLANAR, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
293 .depth = 1, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
294 }, |
1055 | 295 |
296 /* paletted formats */ | |
297 [PIX_FMT_PAL8] = { | |
1204 | 298 .nb_channels = 4, .is_alpha = 1, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
299 .color_type = FF_COLOR_RGB, |
1204 | 300 .pixel_type = FF_PIXEL_PALETTE, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
301 .depth = 8, |
1055 | 302 }, |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
303 [PIX_FMT_UYYVYY411] = { |
2309 | 304 .nb_channels = 1, |
305 .color_type = FF_COLOR_YUV, | |
306 .pixel_type = FF_PIXEL_PACKED, | |
307 .depth = 8, | |
308 }, | |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
309 [PIX_FMT_ABGR] = { |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
310 .nb_channels = 4, .is_alpha = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
311 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
312 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
313 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
314 }, |
9223
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
315 [PIX_FMT_BGR565BE] = { |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
316 .nb_channels = 3, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
317 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
318 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
319 .depth = 5, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
320 }, |
9223
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
321 [PIX_FMT_BGR565LE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
322 .nb_channels = 3, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
323 .color_type = FF_COLOR_RGB, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
324 .pixel_type = FF_PIXEL_PACKED, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
325 .depth = 5, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
326 }, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
327 [PIX_FMT_BGR555BE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
328 .nb_channels = 3, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
329 .color_type = FF_COLOR_RGB, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
330 .pixel_type = FF_PIXEL_PACKED, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
331 .depth = 5, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
332 }, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
333 [PIX_FMT_BGR555LE] = { |
4207
bc9de4875ebd
BGR555 has never been working as alpha supporting format. Remove the false setting.
alex
parents:
4201
diff
changeset
|
334 .nb_channels = 3, |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
335 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
336 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
337 .depth = 5, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
338 }, |
11366 | 339 [PIX_FMT_BGR444BE] = { |
340 .nb_channels = 3, | |
341 .color_type = FF_COLOR_RGB, | |
342 .pixel_type = FF_PIXEL_PACKED, | |
343 .depth = 4, | |
344 }, | |
345 [PIX_FMT_BGR444LE] = { | |
346 .nb_channels = 3, | |
347 .color_type = FF_COLOR_RGB, | |
348 .pixel_type = FF_PIXEL_PACKED, | |
349 .depth = 4, | |
350 }, | |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
351 [PIX_FMT_RGB8] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
352 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
353 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
354 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
355 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
356 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
357 [PIX_FMT_RGB4] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
358 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
359 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
360 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
361 .depth = 4, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
362 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
363 [PIX_FMT_RGB4_BYTE] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
364 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
365 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
366 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
367 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
368 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
369 [PIX_FMT_BGR8] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
370 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
371 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
372 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
373 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
374 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
375 [PIX_FMT_BGR4] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
376 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
377 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
378 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
379 .depth = 4, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
380 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
381 [PIX_FMT_BGR4_BYTE] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
382 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
383 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
384 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
385 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
386 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
387 [PIX_FMT_NV12] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
388 .nb_channels = 2, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
389 .color_type = FF_COLOR_YUV, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
390 .pixel_type = FF_PIXEL_PLANAR, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
391 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
392 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
393 [PIX_FMT_NV21] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
394 .nb_channels = 2, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
395 .color_type = FF_COLOR_YUV, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
396 .pixel_type = FF_PIXEL_PLANAR, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
397 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
398 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
399 |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
400 [PIX_FMT_BGRA] = { |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
401 .nb_channels = 4, .is_alpha = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
402 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
403 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
404 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
405 }, |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
406 [PIX_FMT_RGBA] = { |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
407 .nb_channels = 4, .is_alpha = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
408 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
409 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
410 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
411 }, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
412 }; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
413 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
414 void avcodec_get_chroma_sub_sample(enum PixelFormat pix_fmt, int *h_shift, int *v_shift) |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
415 { |
10573
ac49ab818d4d
Use av_pix_fmt_descriptors in avcodec_get_chroma_sub_sample(), rather
stefano
parents:
10572
diff
changeset
|
416 *h_shift = av_pix_fmt_descriptors[pix_fmt].log2_chroma_w; |
ac49ab818d4d
Use av_pix_fmt_descriptors in avcodec_get_chroma_sub_sample(), rather
stefano
parents:
10572
diff
changeset
|
417 *v_shift = av_pix_fmt_descriptors[pix_fmt].log2_chroma_h; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
418 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
419 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
420 const char *avcodec_get_pix_fmt_name(enum PixelFormat pix_fmt) |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
421 { |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
422 if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB) |
7463
5515e19b9137
Add graceful error handling to avcodec_get_pix_fmt_name() and avcodec_get_pix_fmt().
pross
parents:
6963
diff
changeset
|
423 return NULL; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
424 else |
10579
dacdec913c5b
Make avcodec_get_pix_fmt_name() use av_pix_fmt_descriptors rather than
stefano
parents:
10577
diff
changeset
|
425 return av_pix_fmt_descriptors[pix_fmt].name; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
426 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
427 |
11059
e1bc53867092
Implement av_get_pix_fmt(), and deprecate avcodec_get_pix_fmt().
stefano
parents:
10682
diff
changeset
|
428 #if LIBAVCODEC_VERSION_MAJOR < 53 |
9222
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
429 enum PixelFormat avcodec_get_pix_fmt(const char *name) |
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
430 { |
11059
e1bc53867092
Implement av_get_pix_fmt(), and deprecate avcodec_get_pix_fmt().
stefano
parents:
10682
diff
changeset
|
431 return av_get_pix_fmt(name); |
9222
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
432 } |
11059
e1bc53867092
Implement av_get_pix_fmt(), and deprecate avcodec_get_pix_fmt().
stefano
parents:
10682
diff
changeset
|
433 #endif |
9222
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
434 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
435 void avcodec_pix_fmt_string (char *buf, int buf_size, enum PixelFormat pix_fmt) |
5084
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
436 { |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
437 /* print header */ |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
438 if (pix_fmt < 0) |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
439 snprintf (buf, buf_size, |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
440 "name " " nb_channels" " depth" " is_alpha" |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
441 ); |
6911 | 442 else{ |
443 PixFmtInfo info= pix_fmt_info[pix_fmt]; | |
444 | |
445 char is_alpha_char= info.is_alpha ? 'y' : 'n'; | |
446 | |
5084
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
447 snprintf (buf, buf_size, |
10277 | 448 "%-11s %5d %9d %6c", |
10583
96d1d05cfd37
Use pixel formats names defined in av_pix_fmt_descriptors rather than
stefano
parents:
10582
diff
changeset
|
449 av_pix_fmt_descriptors[pix_fmt].name, |
5084
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
450 info.nb_channels, |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
451 info.depth, |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
452 is_alpha_char |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
453 ); |
6911 | 454 } |
5084
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
455 } |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
456 |
9011
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
457 int ff_is_hwaccel_pix_fmt(enum PixelFormat pix_fmt) |
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
458 { |
10572
a21b640dba50
Use av_pix_fmt_descriptors in ff_is_hwaccel_pix_fmt() rather than
stefano
parents:
10569
diff
changeset
|
459 return av_pix_fmt_descriptors[pix_fmt].flags & PIX_FMT_HWACCEL; |
9011
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
460 } |
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
461 |
8748
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
462 int ff_set_systematic_pal(uint32_t pal[256], enum PixelFormat pix_fmt){ |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
463 int i; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
464 |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
465 for(i=0; i<256; i++){ |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
466 int r,g,b; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
467 |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
468 switch(pix_fmt) { |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
469 case PIX_FMT_RGB8: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
470 r= (i>>5 )*36; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
471 g= ((i>>2)&7)*36; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
472 b= (i&3 )*85; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
473 break; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
474 case PIX_FMT_BGR8: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
475 b= (i>>6 )*85; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
476 g= ((i>>3)&7)*36; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
477 r= (i&7 )*36; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
478 break; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
479 case PIX_FMT_RGB4_BYTE: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
480 r= (i>>3 )*255; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
481 g= ((i>>1)&3)*85; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
482 b= (i&1 )*255; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
483 break; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
484 case PIX_FMT_BGR4_BYTE: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
485 b= (i>>3 )*255; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
486 g= ((i>>1)&3)*85; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
487 r= (i&1 )*255; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
488 break; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
489 case PIX_FMT_GRAY8: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
490 r=b=g= i; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
491 break; |
8788
5e9e735cd793
Add a default (error) for the switch in case of an unsupported PIX_FMT.
gpoirier
parents:
8748
diff
changeset
|
492 default: |
5e9e735cd793
Add a default (error) for the switch in case of an unsupported PIX_FMT.
gpoirier
parents:
8748
diff
changeset
|
493 return -1; |
8748
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
494 } |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
495 pal[i] = b + (g<<8) + (r<<16); |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
496 } |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
497 |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
498 return 0; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
499 } |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
500 |
12320
035ca6548e29
Use av_fill_image_pointers/linesizes in place of ff_fill_pointer/linesize,
stefano
parents:
12317
diff
changeset
|
501 #if LIBAVCODEC_VERSION_MAJOR < 53 |
12277
17adb33ac603
Define static functions fill_image_linesize() and
stefano
parents:
12039
diff
changeset
|
502 int ff_fill_linesize(AVPicture *picture, enum PixelFormat pix_fmt, int width) |
17adb33ac603
Define static functions fill_image_linesize() and
stefano
parents:
12039
diff
changeset
|
503 { |
12298
bfc36c0fea55
Move fill_image_linesize() and fill_image_data_ptr() from
stefano
parents:
12277
diff
changeset
|
504 return av_fill_image_linesizes(picture->linesize, pix_fmt, width); |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
505 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
506 |
12277
17adb33ac603
Define static functions fill_image_linesize() and
stefano
parents:
12039
diff
changeset
|
507 int ff_fill_pointer(AVPicture *picture, uint8_t *ptr, enum PixelFormat pix_fmt, |
17adb33ac603
Define static functions fill_image_linesize() and
stefano
parents:
12039
diff
changeset
|
508 int height) |
17adb33ac603
Define static functions fill_image_linesize() and
stefano
parents:
12039
diff
changeset
|
509 { |
12298
bfc36c0fea55
Move fill_image_linesize() and fill_image_data_ptr() from
stefano
parents:
12277
diff
changeset
|
510 return av_fill_image_pointers(picture->data, pix_fmt, height, ptr, picture->linesize); |
12277
17adb33ac603
Define static functions fill_image_linesize() and
stefano
parents:
12039
diff
changeset
|
511 } |
12320
035ca6548e29
Use av_fill_image_pointers/linesizes in place of ff_fill_pointer/linesize,
stefano
parents:
12317
diff
changeset
|
512 #endif |
12277
17adb33ac603
Define static functions fill_image_linesize() and
stefano
parents:
12039
diff
changeset
|
513 |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
514 int avpicture_fill(AVPicture *picture, uint8_t *ptr, |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
515 enum PixelFormat pix_fmt, int width, int height) |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
516 { |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
517 |
12372
914f484bb476
Remove use of the deprecated function avcodec_check_dimensions(), use
stefano
parents:
12320
diff
changeset
|
518 if(av_check_image_size(width, height, 0, NULL)) |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
519 return -1; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
520 |
12299
6c42dc376222
Make avpicture_fill() directly call av_fill_image_linesizes() and
stefano
parents:
12298
diff
changeset
|
521 if (av_fill_image_linesizes(picture->linesize, pix_fmt, width)) |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
522 return -1; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
523 |
12299
6c42dc376222
Make avpicture_fill() directly call av_fill_image_linesizes() and
stefano
parents:
12298
diff
changeset
|
524 return av_fill_image_pointers(picture->data, pix_fmt, height, ptr, picture->linesize); |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
525 } |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
526 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
527 int avpicture_layout(const AVPicture* src, enum PixelFormat pix_fmt, int width, int height, |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
528 unsigned char *dest, int dest_size) |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
529 { |
3420 | 530 const PixFmtInfo* pf = &pix_fmt_info[pix_fmt]; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
531 const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt]; |
9070
87f496299f09
Fix avpicture_layout to not chroma shift the alpha plane when outputting YUVA420P
sdrik
parents:
9061
diff
changeset
|
532 int i, j, w, ow, h, oh, data_planes; |
2967 | 533 const unsigned char* s; |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
534 int size = avpicture_get_size(pix_fmt, width, height); |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
535 |
2422 | 536 if (size > dest_size || size < 0) |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
537 return -1; |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
538 |
1243
5d2376294fbf
* fixing a bug in avpicture_layout (PAL8 wasn't handled properly)
romansh
parents:
1231
diff
changeset
|
539 if (pf->pixel_type == FF_PIXEL_PACKED || pf->pixel_type == FF_PIXEL_PALETTE) { |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
540 if (pix_fmt == PIX_FMT_YUYV422 || |
2967 | 541 pix_fmt == PIX_FMT_UYVY422 || |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
542 pix_fmt == PIX_FMT_BGR565BE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
543 pix_fmt == PIX_FMT_BGR565LE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
544 pix_fmt == PIX_FMT_BGR555BE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
545 pix_fmt == PIX_FMT_BGR555LE || |
11366 | 546 pix_fmt == PIX_FMT_BGR444BE || |
547 pix_fmt == PIX_FMT_BGR444LE || | |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
548 pix_fmt == PIX_FMT_RGB565BE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
549 pix_fmt == PIX_FMT_RGB565LE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
550 pix_fmt == PIX_FMT_RGB555BE || |
11366 | 551 pix_fmt == PIX_FMT_RGB555LE || |
552 pix_fmt == PIX_FMT_RGB444BE || | |
553 pix_fmt == PIX_FMT_RGB444LE) | |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
554 w = width * 2; |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
555 else if (pix_fmt == PIX_FMT_UYYVYY411) |
10546 | 556 w = width + width/2; |
2979 | 557 else if (pix_fmt == PIX_FMT_PAL8) |
10546 | 558 w = width; |
2979 | 559 else |
10546 | 560 w = width * (pf->depth * pf->nb_channels / 8); |
2967 | 561 |
2979 | 562 data_planes = 1; |
563 h = height; | |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
564 } else { |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
565 data_planes = pf->nb_channels; |
2979 | 566 w = (width*pf->depth + 7)/8; |
567 h = height; | |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
568 } |
2967 | 569 |
9070
87f496299f09
Fix avpicture_layout to not chroma shift the alpha plane when outputting YUVA420P
sdrik
parents:
9061
diff
changeset
|
570 ow = w; |
87f496299f09
Fix avpicture_layout to not chroma shift the alpha plane when outputting YUVA420P
sdrik
parents:
9061
diff
changeset
|
571 oh = h; |
87f496299f09
Fix avpicture_layout to not chroma shift the alpha plane when outputting YUVA420P
sdrik
parents:
9061
diff
changeset
|
572 |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
573 for (i=0; i<data_planes; i++) { |
10546 | 574 if (i == 1) { |
11367 | 575 w = (- ((-width) >> desc->log2_chroma_w) * pf->depth + 7) / 8; |
576 h = -((-height) >> desc->log2_chroma_h); | |
10569
7a8b35405591
Fix nv12/nv21 handling. linesize for plane 1 should account for both chroma
ramiro
parents:
10546
diff
changeset
|
577 if (pix_fmt == PIX_FMT_NV12 || pix_fmt == PIX_FMT_NV21) |
7a8b35405591
Fix nv12/nv21 handling. linesize for plane 1 should account for both chroma
ramiro
parents:
10546
diff
changeset
|
578 w <<= 1; |
10546 | 579 } else if (i == 3) { |
580 w = ow; | |
581 h = oh; | |
582 } | |
583 s = src->data[i]; | |
584 for(j=0; j<h; j++) { | |
585 memcpy(dest, s, w); | |
586 dest += w; | |
587 s += src->linesize[i]; | |
588 } | |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
589 } |
2967 | 590 |
1243
5d2376294fbf
* fixing a bug in avpicture_layout (PAL8 wasn't handled properly)
romansh
parents:
1231
diff
changeset
|
591 if (pf->pixel_type == FF_PIXEL_PALETTE) |
2979 | 592 memcpy((unsigned char *)(((size_t)dest + 3) & ~3), src->data[1], 256 * 4); |
2967 | 593 |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
594 return size; |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
595 } |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
596 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
597 int avpicture_get_size(enum PixelFormat pix_fmt, int width, int height) |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
598 { |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
599 AVPicture dummy_pict; |
12372
914f484bb476
Remove use of the deprecated function avcodec_check_dimensions(), use
stefano
parents:
12320
diff
changeset
|
600 if(av_check_image_size(width, height, 0, NULL)) |
9217
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
601 return -1; |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
602 switch (pix_fmt) { |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
603 case PIX_FMT_RGB8: |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
604 case PIX_FMT_BGR8: |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
605 case PIX_FMT_RGB4_BYTE: |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
606 case PIX_FMT_BGR4_BYTE: |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
607 case PIX_FMT_GRAY8: |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
608 // do not include palette for these pseudo-paletted formats |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
609 return width * height; |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
610 } |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
611 return avpicture_fill(&dummy_pict, NULL, pix_fmt, width, height); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
612 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
613 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
614 int avcodec_get_pix_fmt_loss(enum PixelFormat dst_pix_fmt, enum PixelFormat src_pix_fmt, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
615 int has_alpha) |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
616 { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
617 const PixFmtInfo *pf, *ps; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
618 const AVPixFmtDescriptor *src_desc = &av_pix_fmt_descriptors[src_pix_fmt]; |
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
619 const AVPixFmtDescriptor *dst_desc = &av_pix_fmt_descriptors[dst_pix_fmt]; |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
620 int loss; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
621 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
622 ps = &pix_fmt_info[src_pix_fmt]; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
623 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
624 /* compute loss */ |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
625 loss = 0; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
626 pf = &pix_fmt_info[dst_pix_fmt]; |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
627 if (pf->depth < ps->depth || |
11365
eb03ee2f7781
Fix BGR cases missing from depth test in avcodec_get_pix_fmt_loss().
stefano
parents:
11318
diff
changeset
|
628 ((dst_pix_fmt == PIX_FMT_RGB555BE || dst_pix_fmt == PIX_FMT_RGB555LE || |
eb03ee2f7781
Fix BGR cases missing from depth test in avcodec_get_pix_fmt_loss().
stefano
parents:
11318
diff
changeset
|
629 dst_pix_fmt == PIX_FMT_BGR555BE || dst_pix_fmt == PIX_FMT_BGR555LE) && |
eb03ee2f7781
Fix BGR cases missing from depth test in avcodec_get_pix_fmt_loss().
stefano
parents:
11318
diff
changeset
|
630 (src_pix_fmt == PIX_FMT_RGB565BE || src_pix_fmt == PIX_FMT_RGB565LE || |
eb03ee2f7781
Fix BGR cases missing from depth test in avcodec_get_pix_fmt_loss().
stefano
parents:
11318
diff
changeset
|
631 src_pix_fmt == PIX_FMT_BGR565BE || src_pix_fmt == PIX_FMT_BGR565LE))) |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
632 loss |= FF_LOSS_DEPTH; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
633 if (dst_desc->log2_chroma_w > src_desc->log2_chroma_w || |
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
634 dst_desc->log2_chroma_h > src_desc->log2_chroma_h) |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
635 loss |= FF_LOSS_RESOLUTION; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
636 switch(pf->color_type) { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
637 case FF_COLOR_RGB: |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
638 if (ps->color_type != FF_COLOR_RGB && |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
639 ps->color_type != FF_COLOR_GRAY) |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
640 loss |= FF_LOSS_COLORSPACE; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
641 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
642 case FF_COLOR_GRAY: |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
643 if (ps->color_type != FF_COLOR_GRAY) |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
644 loss |= FF_LOSS_COLORSPACE; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
645 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
646 case FF_COLOR_YUV: |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
647 if (ps->color_type != FF_COLOR_YUV) |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
648 loss |= FF_LOSS_COLORSPACE; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
649 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
650 case FF_COLOR_YUV_JPEG: |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
651 if (ps->color_type != FF_COLOR_YUV_JPEG && |
2967 | 652 ps->color_type != FF_COLOR_YUV && |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
653 ps->color_type != FF_COLOR_GRAY) |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
654 loss |= FF_LOSS_COLORSPACE; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
655 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
656 default: |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
657 /* fail safe test */ |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
658 if (ps->color_type != pf->color_type) |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
659 loss |= FF_LOSS_COLORSPACE; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
660 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
661 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
662 if (pf->color_type == FF_COLOR_GRAY && |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
663 ps->color_type != FF_COLOR_GRAY) |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
664 loss |= FF_LOSS_CHROMA; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
665 if (!pf->is_alpha && (ps->is_alpha && has_alpha)) |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
666 loss |= FF_LOSS_ALPHA; |
2967 | 667 if (pf->pixel_type == FF_PIXEL_PALETTE && |
1204 | 668 (ps->pixel_type != FF_PIXEL_PALETTE && ps->color_type != FF_COLOR_GRAY)) |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
669 loss |= FF_LOSS_COLORQUANT; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
670 return loss; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
671 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
672 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
673 static int avg_bits_per_pixel(enum PixelFormat pix_fmt) |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
674 { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
675 int bits; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
676 const PixFmtInfo *pf; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
677 const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt]; |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
678 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
679 pf = &pix_fmt_info[pix_fmt]; |
1204 | 680 switch(pf->pixel_type) { |
681 case FF_PIXEL_PACKED: | |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
682 switch(pix_fmt) { |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
683 case PIX_FMT_YUYV422: |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
684 case PIX_FMT_UYVY422: |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
685 case PIX_FMT_RGB565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
686 case PIX_FMT_RGB565LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
687 case PIX_FMT_RGB555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
688 case PIX_FMT_RGB555LE: |
11366 | 689 case PIX_FMT_RGB444BE: |
690 case PIX_FMT_RGB444LE: | |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
691 case PIX_FMT_BGR565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
692 case PIX_FMT_BGR565LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
693 case PIX_FMT_BGR555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
694 case PIX_FMT_BGR555LE: |
11366 | 695 case PIX_FMT_BGR444BE: |
696 case PIX_FMT_BGR444LE: | |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
697 bits = 16; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
698 break; |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
699 case PIX_FMT_UYYVYY411: |
2979 | 700 bits = 12; |
701 break; | |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
702 default: |
1204 | 703 bits = pf->depth * pf->nb_channels; |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
704 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
705 } |
1204 | 706 break; |
707 case FF_PIXEL_PLANAR: | |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
708 if (desc->log2_chroma_w == 0 && desc->log2_chroma_h == 0) { |
1204 | 709 bits = pf->depth * pf->nb_channels; |
710 } else { | |
2967 | 711 bits = pf->depth + ((2 * pf->depth) >> |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
712 (desc->log2_chroma_w + desc->log2_chroma_h)); |
1204 | 713 } |
714 break; | |
715 case FF_PIXEL_PALETTE: | |
716 bits = 8; | |
717 break; | |
718 default: | |
719 bits = -1; | |
720 break; | |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
721 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
722 return bits; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
723 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
724 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
725 static enum PixelFormat avcodec_find_best_pix_fmt1(int64_t pix_fmt_mask, |
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
726 enum PixelFormat src_pix_fmt, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
727 int has_alpha, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
728 int loss_mask) |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
729 { |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
730 int dist, i, loss, min_dist; |
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
731 enum PixelFormat dst_pix_fmt; |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
732 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
733 /* find exact color match with smallest size */ |
10682
aa8bebc96764
Use PIX_FMT_NONE for -1 when enum PixelFormat is expected (fixes two icc warnings).
cehoyos
parents:
10640
diff
changeset
|
734 dst_pix_fmt = PIX_FMT_NONE; |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
735 min_dist = 0x7fffffff; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
736 for(i = 0;i < PIX_FMT_NB; i++) { |
8321
e9db9859de6c
Prevent shift overflow, patch by Anders Gr«Ónberg, galileo.m2 gmail com.
diego
parents:
8316
diff
changeset
|
737 if (pix_fmt_mask & (1ULL << i)) { |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
738 loss = avcodec_get_pix_fmt_loss(i, src_pix_fmt, has_alpha) & loss_mask; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
739 if (loss == 0) { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
740 dist = avg_bits_per_pixel(i); |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
741 if (dist < min_dist) { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
742 min_dist = dist; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
743 dst_pix_fmt = i; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
744 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
745 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
746 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
747 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
748 return dst_pix_fmt; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
749 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
750 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
751 enum PixelFormat avcodec_find_best_pix_fmt(int64_t pix_fmt_mask, enum PixelFormat src_pix_fmt, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
752 int has_alpha, int *loss_ptr) |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
753 { |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
754 enum PixelFormat dst_pix_fmt; |
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
755 int loss_mask, i; |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
756 static const int loss_mask_order[] = { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
757 ~0, /* no loss first */ |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
758 ~FF_LOSS_ALPHA, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
759 ~FF_LOSS_RESOLUTION, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
760 ~(FF_LOSS_COLORSPACE | FF_LOSS_RESOLUTION), |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
761 ~FF_LOSS_COLORQUANT, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
762 ~FF_LOSS_DEPTH, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
763 0, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
764 }; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
765 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
766 /* try with successive loss */ |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
767 i = 0; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
768 for(;;) { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
769 loss_mask = loss_mask_order[i++]; |
2967 | 770 dst_pix_fmt = avcodec_find_best_pix_fmt1(pix_fmt_mask, src_pix_fmt, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
771 has_alpha, loss_mask); |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
772 if (dst_pix_fmt >= 0) |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
773 goto found; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
774 if (loss_mask == 0) |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
775 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
776 } |
10682
aa8bebc96764
Use PIX_FMT_NONE for -1 when enum PixelFormat is expected (fixes two icc warnings).
cehoyos
parents:
10640
diff
changeset
|
777 return PIX_FMT_NONE; |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
778 found: |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
779 if (loss_ptr) |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
780 *loss_ptr = avcodec_get_pix_fmt_loss(dst_pix_fmt, src_pix_fmt, has_alpha); |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
781 return dst_pix_fmt; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
782 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
783 |
3245 | 784 void ff_img_copy_plane(uint8_t *dst, int dst_wrap, |
1205 | 785 const uint8_t *src, int src_wrap, |
786 int width, int height) | |
1204 | 787 { |
12395 | 788 if (!dst || !src) |
2785 | 789 return; |
1204 | 790 for(;height > 0; height--) { |
791 memcpy(dst, src, width); | |
792 dst += dst_wrap; | |
793 src += src_wrap; | |
794 } | |
795 } | |
796 | |
12387 | 797 #if LIBAVCODEC_VERSION_MAJOR < 53 |
6358 | 798 int ff_get_plane_bytewidth(enum PixelFormat pix_fmt, int width, int plane) |
1204 | 799 { |
12386 | 800 return av_get_image_linesize(pix_fmt, width, plane); |
6347 | 801 } |
12387 | 802 #endif |
6347 | 803 |
12384
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
804 void av_picture_data_copy(uint8_t *dst_data[4], int dst_linesize[4], |
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
805 uint8_t *src_data[4], int src_linesize[4], |
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
806 enum PixelFormat pix_fmt, int width, int height) |
6347 | 807 { |
808 int i; | |
809 const PixFmtInfo *pf = &pix_fmt_info[pix_fmt]; | |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
810 const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt]; |
6347 | 811 |
812 switch(pf->pixel_type) { | |
813 case FF_PIXEL_PACKED: | |
1204 | 814 case FF_PIXEL_PLANAR: |
815 for(i = 0; i < pf->nb_channels; i++) { | |
8087
661cd381d996
Remove unused variable, patch by Art Clarke, aclarke vlideshow com.
diego
parents:
8083
diff
changeset
|
816 int h; |
12387 | 817 int bwidth = av_get_image_linesize(pix_fmt, width, i); |
1204 | 818 h = height; |
819 if (i == 1 || i == 2) { | |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
820 h= -((-height)>>desc->log2_chroma_h); |
1204 | 821 } |
12384
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
822 ff_img_copy_plane(dst_data[i], dst_linesize[i], |
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
823 src_data[i], src_linesize[i], |
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
824 bwidth, h); |
1204 | 825 } |
826 break; | |
827 case FF_PIXEL_PALETTE: | |
12384
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
828 ff_img_copy_plane(dst_data[0], dst_linesize[0], |
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
829 src_data[0], src_linesize[0], |
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
830 width, height); |
1204 | 831 /* copy the palette */ |
12384
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
832 memcpy(dst_data[1], src_data[1], 4*256); |
1204 | 833 break; |
834 } | |
835 } | |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
836 |
12384
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
837 void av_picture_copy(AVPicture *dst, const AVPicture *src, |
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
838 enum PixelFormat pix_fmt, int width, int height) |
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
839 { |
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
840 av_picture_data_copy(dst->data, dst->linesize, src->data, |
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
841 src->linesize, pix_fmt, width, height); |
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
842 } |
e1ef713061ce
Add av_picture_data_copy() and reimplement av_picture_copy() as a
stefano
parents:
12372
diff
changeset
|
843 |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
844 /* 2x2 -> 1x1 */ |
3245 | 845 void ff_shrink22(uint8_t *dst, int dst_wrap, |
1205 | 846 const uint8_t *src, int src_wrap, |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
847 int width, int height) |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
848 { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
849 int w; |
1205 | 850 const uint8_t *s1, *s2; |
851 uint8_t *d; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
852 |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
853 for(;height > 0; height--) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
854 s1 = src; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
855 s2 = s1 + src_wrap; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
856 d = dst; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
857 for(w = width;w >= 4; w-=4) { |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
858 d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2; |
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
859 d[1] = (s1[2] + s1[3] + s2[2] + s2[3] + 2) >> 2; |
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
860 d[2] = (s1[4] + s1[5] + s2[4] + s2[5] + 2) >> 2; |
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
861 d[3] = (s1[6] + s1[7] + s2[6] + s2[7] + 2) >> 2; |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
862 s1 += 8; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
863 s2 += 8; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
864 d += 4; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
865 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
866 for(;w > 0; w--) { |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
867 d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2; |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
868 s1 += 2; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
869 s2 += 2; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
870 d++; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
871 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
872 src += 2 * src_wrap; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
873 dst += dst_wrap; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
874 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
875 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
876 |
1205 | 877 /* 4x4 -> 1x1 */ |
3245 | 878 void ff_shrink44(uint8_t *dst, int dst_wrap, |
1205 | 879 const uint8_t *src, int src_wrap, |
576
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
880 int width, int height) |
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
881 { |
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
882 int w; |
1205 | 883 const uint8_t *s1, *s2, *s3, *s4; |
884 uint8_t *d; | |
576
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
885 |
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
886 for(;height > 0; height--) { |
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
887 s1 = src; |
1205 | 888 s2 = s1 + src_wrap; |
889 s3 = s2 + src_wrap; | |
890 s4 = s3 + src_wrap; | |
576
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
891 d = dst; |
1205 | 892 for(w = width;w > 0; w--) { |
893 d[0] = (s1[0] + s1[1] + s1[2] + s1[3] + | |
894 s2[0] + s2[1] + s2[2] + s2[3] + | |
895 s3[0] + s3[1] + s3[2] + s3[3] + | |
896 s4[0] + s4[1] + s4[2] + s4[3] + 8) >> 4; | |
897 s1 += 4; | |
898 s2 += 4; | |
899 s3 += 4; | |
900 s4 += 4; | |
576
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
901 d++; |
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
902 } |
1205 | 903 src += 4 * src_wrap; |
904 dst += dst_wrap; | |
905 } | |
906 } | |
907 | |
3245 | 908 /* 8x8 -> 1x1 */ |
909 void ff_shrink88(uint8_t *dst, int dst_wrap, | |
910 const uint8_t *src, int src_wrap, | |
911 int width, int height) | |
912 { | |
913 int w, i; | |
914 | |
915 for(;height > 0; height--) { | |
916 for(w = width;w > 0; w--) { | |
917 int tmp=0; | |
918 for(i=0; i<8; i++){ | |
919 tmp += src[0] + src[1] + src[2] + src[3] + src[4] + src[5] + src[6] + src[7]; | |
920 src += src_wrap; | |
921 } | |
922 *(dst++) = (tmp + 32)>>6; | |
923 src += 8 - 8*src_wrap; | |
924 } | |
925 src += 8*src_wrap - 8*width; | |
926 dst += dst_wrap - width; | |
927 } | |
928 } | |
929 | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
930 |
1508 | 931 int avpicture_alloc(AVPicture *picture, |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
932 enum PixelFormat pix_fmt, int width, int height) |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
933 { |
3266
3b785e80ce3e
make "size" variable in avpicture_alloc signed, since avpicture_get_size
reimar
parents:
3257
diff
changeset
|
934 int size; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
935 void *ptr; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
936 |
9217
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
937 size = avpicture_fill(picture, NULL, pix_fmt, width, height); |
2422 | 938 if(size<0) |
939 goto fail; | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
940 ptr = av_malloc(size); |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
941 if (!ptr) |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
942 goto fail; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
943 avpicture_fill(picture, ptr, pix_fmt, width, height); |
8748
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
944 if(picture->data[1] && !picture->data[2]) |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
945 ff_set_systematic_pal((uint32_t*)picture->data[1], pix_fmt); |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
946 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
947 return 0; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
948 fail: |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
949 memset(picture, 0, sizeof(AVPicture)); |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
950 return -1; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
951 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
952 |
1508 | 953 void avpicture_free(AVPicture *picture) |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
954 { |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
1028
diff
changeset
|
955 av_free(picture->data[0]); |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
956 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
957 |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
958 /* return true if yuv planar */ |
3420 | 959 static inline int is_yuv_planar(const PixFmtInfo *ps) |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
960 { |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
961 return (ps->color_type == FF_COLOR_YUV || |
2967 | 962 ps->color_type == FF_COLOR_YUV_JPEG) && |
1204 | 963 ps->pixel_type == FF_PIXEL_PLANAR; |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
964 } |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
965 |
4624
6a900f539e2c
Add the prefix "av_" to img_crop(), img_copy() and img_pad(), and rename "img"
takis
parents:
4593
diff
changeset
|
966 int av_picture_crop(AVPicture *dst, const AVPicture *src, |
9902
9bdf9fe9018c
Fix argument type mismatches for av_picture_crop and av_picture_fill
mru
parents:
9519
diff
changeset
|
967 enum PixelFormat pix_fmt, int top_band, int left_band) |
3179 | 968 { |
969 int y_shift; | |
970 int x_shift; | |
971 | |
972 if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB || !is_yuv_planar(&pix_fmt_info[pix_fmt])) | |
973 return -1; | |
974 | |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
975 y_shift = av_pix_fmt_descriptors[pix_fmt].log2_chroma_h; |
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
976 x_shift = av_pix_fmt_descriptors[pix_fmt].log2_chroma_w; |
3179 | 977 |
978 dst->data[0] = src->data[0] + (top_band * src->linesize[0]) + left_band; | |
979 dst->data[1] = src->data[1] + ((top_band >> y_shift) * src->linesize[1]) + (left_band >> x_shift); | |
980 dst->data[2] = src->data[2] + ((top_band >> y_shift) * src->linesize[2]) + (left_band >> x_shift); | |
981 | |
982 dst->linesize[0] = src->linesize[0]; | |
983 dst->linesize[1] = src->linesize[1]; | |
984 dst->linesize[2] = src->linesize[2]; | |
985 return 0; | |
986 } | |
987 | |
4624
6a900f539e2c
Add the prefix "av_" to img_crop(), img_copy() and img_pad(), and rename "img"
takis
parents:
4593
diff
changeset
|
988 int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
989 enum PixelFormat pix_fmt, int padtop, int padbottom, int padleft, int padright, |
4358 | 990 int *color) |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
991 { |
4359
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
992 uint8_t *optr; |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
993 int y_shift; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
994 int x_shift; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
995 int yheight; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
996 int i, y; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
997 |
4358 | 998 if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB || |
999 !is_yuv_planar(&pix_fmt_info[pix_fmt])) return -1; | |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1000 |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1001 for (i = 0; i < 3; i++) { |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
1002 x_shift = i ? av_pix_fmt_descriptors[pix_fmt].log2_chroma_w : 0; |
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
1003 y_shift = i ? av_pix_fmt_descriptors[pix_fmt].log2_chroma_h : 0; |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1004 |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1005 if (padtop || padleft) { |
4358 | 1006 memset(dst->data[i], color[i], |
1007 dst->linesize[i] * (padtop >> y_shift) + (padleft >> x_shift)); | |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1008 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1009 |
4359
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1010 if (padleft || padright) { |
4358 | 1011 optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) + |
1012 (dst->linesize[i] - (padright >> x_shift)); | |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1013 yheight = (height - 1 - (padtop + padbottom)) >> y_shift; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1014 for (y = 0; y < yheight; y++) { |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1015 memset(optr, color[i], (padleft + padright) >> x_shift); |
4359
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1016 optr += dst->linesize[i]; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1017 } |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1018 } |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1019 |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1020 if (src) { /* first line */ |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1021 uint8_t *iptr = src->data[i]; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1022 optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) + |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1023 (padleft >> x_shift); |
6963
cc2c5a21a0eb
memcpy considering output width, not src linesize, fix segv with av_picture_pad
bcoudurier
parents:
6911
diff
changeset
|
1024 memcpy(optr, iptr, (width - padleft - padright) >> x_shift); |
4359
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1025 iptr += src->linesize[i]; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1026 optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) + |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1027 (dst->linesize[i] - (padright >> x_shift)); |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1028 yheight = (height - 1 - (padtop + padbottom)) >> y_shift; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1029 for (y = 0; y < yheight; y++) { |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1030 memset(optr, color[i], (padleft + padright) >> x_shift); |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1031 memcpy(optr + ((padleft + padright) >> x_shift), iptr, |
6963
cc2c5a21a0eb
memcpy considering output width, not src linesize, fix segv with av_picture_pad
bcoudurier
parents:
6911
diff
changeset
|
1032 (width - padleft - padright) >> x_shift); |
4359
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1033 iptr += src->linesize[i]; |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1034 optr += dst->linesize[i]; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1035 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1036 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1037 |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1038 if (padbottom || padright) { |
4358 | 1039 optr = dst->data[i] + dst->linesize[i] * |
1040 ((height - padbottom) >> y_shift) - (padright >> x_shift); | |
1041 memset(optr, color[i],dst->linesize[i] * | |
1042 (padbottom >> y_shift) + (padright >> x_shift)); | |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1043 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1044 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1045 return 0; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1046 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1047 |
1208 | 1048 /* NOTE: we scan all the pixels to have an exact information */ |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1049 static int get_alpha_info_pal8(const AVPicture *src, int width, int height) |
1208 | 1050 { |
1051 const unsigned char *p; | |
1052 int src_wrap, ret, x, y; | |
1053 unsigned int a; | |
1054 uint32_t *palette = (uint32_t *)src->data[1]; | |
2967 | 1055 |
1208 | 1056 p = src->data[0]; |
1057 src_wrap = src->linesize[0] - width; | |
1058 ret = 0; | |
1059 for(y=0;y<height;y++) { | |
1060 for(x=0;x<width;x++) { | |
1061 a = palette[p[0]] >> 24; | |
1062 if (a == 0x00) { | |
1063 ret |= FF_ALPHA_TRANSP; | |
1064 } else if (a != 0xff) { | |
1065 ret |= FF_ALPHA_SEMI_TRANSP; | |
1066 } | |
1067 p++; | |
1068 } | |
1069 p += src_wrap; | |
1070 } | |
1071 return ret; | |
1072 } | |
1073 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1074 int img_get_alpha_info(const AVPicture *src, |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
1075 enum PixelFormat pix_fmt, int width, int height) |
1208 | 1076 { |
3420 | 1077 const PixFmtInfo *pf = &pix_fmt_info[pix_fmt]; |
1208 | 1078 int ret; |
1079 | |
1080 /* no alpha can be represented in format */ | |
1081 if (!pf->is_alpha) | |
1082 return 0; | |
1083 switch(pix_fmt) { | |
1084 case PIX_FMT_PAL8: | |
1085 ret = get_alpha_info_pal8(src, width, height); | |
1086 break; | |
1087 default: | |
1088 /* we do not know, so everything is indicated */ | |
1089 ret = FF_ALPHA_TRANSP | FF_ALPHA_SEMI_TRANSP; | |
1090 break; | |
1091 } | |
1092 return ret; | |
1093 } | |
801 | 1094 |
12317 | 1095 #if !(HAVE_MMX && HAVE_YASM) |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1096 /* filter parameters: [-1 4 2 4 -1] // 8 */ |
12316 | 1097 static void deinterlace_line_c(uint8_t *dst, |
2979 | 1098 const uint8_t *lum_m4, const uint8_t *lum_m3, |
1099 const uint8_t *lum_m2, const uint8_t *lum_m1, | |
1100 const uint8_t *lum, | |
1101 int size) | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1102 { |
4176 | 1103 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1104 int sum; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1105 |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1106 for(;size > 0;size--) { |
801 | 1107 sum = -lum_m4[0]; |
1108 sum += lum_m3[0] << 2; | |
1109 sum += lum_m2[0] << 1; | |
1110 sum += lum_m1[0] << 2; | |
1111 sum += -lum[0]; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1112 dst[0] = cm[(sum + 4) >> 3]; |
801 | 1113 lum_m4++; |
1114 lum_m3++; | |
1115 lum_m2++; | |
1116 lum_m1++; | |
1117 lum++; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1118 dst++; |
801 | 1119 } |
12316 | 1120 } |
801 | 1121 |
12316 | 1122 static void deinterlace_line_inplace_c(uint8_t *lum_m4, uint8_t *lum_m3, |
1123 uint8_t *lum_m2, uint8_t *lum_m1, | |
1124 uint8_t *lum, int size) | |
801 | 1125 { |
4176 | 1126 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
801 | 1127 int sum; |
1128 | |
1129 for(;size > 0;size--) { | |
1130 sum = -lum_m4[0]; | |
1131 sum += lum_m3[0] << 2; | |
1132 sum += lum_m2[0] << 1; | |
1133 lum_m4[0]=lum_m2[0]; | |
1134 sum += lum_m1[0] << 2; | |
1135 sum += -lum[0]; | |
1136 lum_m2[0] = cm[(sum + 4) >> 3]; | |
1137 lum_m4++; | |
1138 lum_m3++; | |
1139 lum_m2++; | |
1140 lum_m1++; | |
1141 lum++; | |
1142 } | |
12316 | 1143 } |
801 | 1144 #endif |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1145 |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1146 /* deinterlacing : 2 temporal taps, 3 spatial taps linear filter. The |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1147 top field is copied as is, but the bottom field is deinterlaced |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1148 against the top field. */ |
1064 | 1149 static void deinterlace_bottom_field(uint8_t *dst, int dst_wrap, |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1150 const uint8_t *src1, int src_wrap, |
801 | 1151 int width, int height) |
1152 { | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1153 const uint8_t *src_m2, *src_m1, *src_0, *src_p1, *src_p2; |
801 | 1154 int y; |
1155 | |
1156 src_m2 = src1; | |
1157 src_m1 = src1; | |
1158 src_0=&src_m1[src_wrap]; | |
1159 src_p1=&src_0[src_wrap]; | |
1160 src_p2=&src_p1[src_wrap]; | |
1161 for(y=0;y<(height-2);y+=2) { | |
1162 memcpy(dst,src_m1,width); | |
1163 dst += dst_wrap; | |
1164 deinterlace_line(dst,src_m2,src_m1,src_0,src_p1,src_p2,width); | |
1165 src_m2 = src_0; | |
1166 src_m1 = src_p1; | |
1167 src_0 = src_p2; | |
1168 src_p1 += 2*src_wrap; | |
1169 src_p2 += 2*src_wrap; | |
1170 dst += dst_wrap; | |
1171 } | |
1172 memcpy(dst,src_m1,width); | |
1173 dst += dst_wrap; | |
1174 /* do last line */ | |
1175 deinterlace_line(dst,src_m2,src_m1,src_0,src_0,src_0,width); | |
1176 } | |
1177 | |
1064 | 1178 static void deinterlace_bottom_field_inplace(uint8_t *src1, int src_wrap, |
2979 | 1179 int width, int height) |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1180 { |
1064 | 1181 uint8_t *src_m1, *src_0, *src_p1, *src_p2; |
801 | 1182 int y; |
1064 | 1183 uint8_t *buf; |
1184 buf = (uint8_t*)av_malloc(width); | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1185 |
801 | 1186 src_m1 = src1; |
1187 memcpy(buf,src_m1,width); | |
1188 src_0=&src_m1[src_wrap]; | |
1189 src_p1=&src_0[src_wrap]; | |
1190 src_p2=&src_p1[src_wrap]; | |
1191 for(y=0;y<(height-2);y+=2) { | |
1192 deinterlace_line_inplace(buf,src_m1,src_0,src_p1,src_p2,width); | |
1193 src_m1 = src_p1; | |
1194 src_0 = src_p2; | |
1195 src_p1 += 2*src_wrap; | |
1196 src_p2 += 2*src_wrap; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1197 } |
801 | 1198 /* do last line */ |
1199 deinterlace_line_inplace(buf,src_m1,src_0,src_0,src_0,width); | |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
315
diff
changeset
|
1200 av_free(buf); |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1201 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1202 |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1203 int avpicture_deinterlace(AVPicture *dst, const AVPicture *src, |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
1204 enum PixelFormat pix_fmt, int width, int height) |
0 | 1205 { |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1206 int i; |
0 | 1207 |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1208 if (pix_fmt != PIX_FMT_YUV420P && |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1209 pix_fmt != PIX_FMT_YUV422P && |
1425
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
1210 pix_fmt != PIX_FMT_YUV444P && |
5810 | 1211 pix_fmt != PIX_FMT_YUV411P && |
1212 pix_fmt != PIX_FMT_GRAY8) | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1213 return -1; |
801 | 1214 if ((width & 3) != 0 || (height & 3) != 0) |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1215 return -1; |
801 | 1216 |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1217 for(i=0;i<3;i++) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1218 if (i == 1) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1219 switch(pix_fmt) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1220 case PIX_FMT_YUV420P: |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1221 width >>= 1; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1222 height >>= 1; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1223 break; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1224 case PIX_FMT_YUV422P: |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1225 width >>= 1; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1226 break; |
1425
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
1227 case PIX_FMT_YUV411P: |
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
1228 width >>= 2; |
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
1229 break; |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1230 default: |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1231 break; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1232 } |
5810 | 1233 if (pix_fmt == PIX_FMT_GRAY8) { |
1234 break; | |
1235 } | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1236 } |
801 | 1237 if (src == dst) { |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1238 deinterlace_bottom_field_inplace(dst->data[i], dst->linesize[i], |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1239 width, height); |
801 | 1240 } else { |
1241 deinterlace_bottom_field(dst->data[i],dst->linesize[i], | |
1242 src->data[i], src->linesize[i], | |
1243 width, height); | |
1244 } | |
0 | 1245 } |
5735 | 1246 emms_c(); |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1247 return 0; |
0 | 1248 } |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
1249 |