Mercurial > libavcodec.hg
annotate imgconvert.c @ 12197:fbf4d5b1b664 libavcodec
Remove FF_MM_SSE2/3 flags for CPUs where this is generally not faster than
regular MMX code. Examples of this are the Core1 CPU. Instead, set a new flag,
FF_MM_SSE2/3SLOW, which can be checked for particular SSE2/3 functions that
have been checked specifically on such CPUs and are actually faster than
their MMX counterparts.
In addition, use this flag to enable particular VP8 and LPC SSE2 functions
that are faster than their MMX counterparts.
Based on a patch by Loren Merritt <lorenm AT u washington edu>.
author | rbultje |
---|---|
date | Mon, 19 Jul 2010 22:38:23 +0000 |
parents | d5705b52b76e |
children | 17adb33ac603 |
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" |
0 | 39 |
8590 | 40 #if HAVE_MMX |
8430 | 41 #include "x86/mmx.h" |
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 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
57 typedef struct PixFmtInfo { |
4549 | 58 uint8_t nb_channels; /**< number of channels (including alpha) */ |
59 uint8_t color_type; /**< color type (see FF_COLOR_xxx constants) */ | |
60 uint8_t pixel_type; /**< pixel storage type (see FF_PIXEL_xxx constants) */ | |
61 uint8_t is_alpha : 1; /**< true if alpha can be specified */ | |
62 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
|
63 } PixFmtInfo; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
64 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
65 /* this table gives more information about formats */ |
3420 | 66 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
|
67 /* YUV formats */ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
68 [PIX_FMT_YUV420P] = { |
1204 | 69 .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
|
70 .color_type = FF_COLOR_YUV, |
1204 | 71 .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
|
72 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
73 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
74 [PIX_FMT_YUV422P] = { |
1204 | 75 .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
|
76 .color_type = FF_COLOR_YUV, |
1204 | 77 .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
|
78 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
79 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
80 [PIX_FMT_YUV444P] = { |
1204 | 81 .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
|
82 .color_type = FF_COLOR_YUV, |
1204 | 83 .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
|
84 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
85 }, |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
86 [PIX_FMT_YUYV422] = { |
1204 | 87 .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
|
88 .color_type = FF_COLOR_YUV, |
1204 | 89 .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
|
90 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
91 }, |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
92 [PIX_FMT_UYVY422] = { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
93 .nb_channels = 1, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
94 .color_type = FF_COLOR_YUV, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
95 .pixel_type = FF_PIXEL_PACKED, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
96 .depth = 8, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
97 }, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
98 [PIX_FMT_YUV410P] = { |
1204 | 99 .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
|
100 .color_type = FF_COLOR_YUV, |
1204 | 101 .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
|
102 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
103 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
104 [PIX_FMT_YUV411P] = { |
1204 | 105 .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
|
106 .color_type = FF_COLOR_YUV, |
1204 | 107 .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
|
108 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
109 }, |
5363 | 110 [PIX_FMT_YUV440P] = { |
111 .nb_channels = 3, | |
112 .color_type = FF_COLOR_YUV, | |
113 .pixel_type = FF_PIXEL_PLANAR, | |
114 .depth = 8, | |
115 }, | |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
116 [PIX_FMT_YUV420P16LE] = { |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
117 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
118 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
119 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
120 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
121 }, |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
122 [PIX_FMT_YUV422P16LE] = { |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
123 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
124 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
125 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
126 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
127 }, |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
128 [PIX_FMT_YUV444P16LE] = { |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
129 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
130 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
131 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
132 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
133 }, |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
134 [PIX_FMT_YUV420P16BE] = { |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
135 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
136 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
137 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
138 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
139 }, |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
140 [PIX_FMT_YUV422P16BE] = { |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
141 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
142 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
143 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
144 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
145 }, |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
146 [PIX_FMT_YUV444P16BE] = { |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
147 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
148 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
149 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
150 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
151 }, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
152 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
153 |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
154 /* YUV formats with alpha plane */ |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
155 [PIX_FMT_YUVA420P] = { |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
156 .nb_channels = 4, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
157 .color_type = FF_COLOR_YUV, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
158 .pixel_type = FF_PIXEL_PLANAR, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
159 .depth = 8, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
160 }, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
161 |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
162 /* JPEG YUV */ |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
163 [PIX_FMT_YUVJ420P] = { |
1204 | 164 .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
|
165 .color_type = FF_COLOR_YUV_JPEG, |
1204 | 166 .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
|
167 .depth = 8, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
168 }, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
169 [PIX_FMT_YUVJ422P] = { |
1204 | 170 .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
|
171 .color_type = FF_COLOR_YUV_JPEG, |
1204 | 172 .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
|
173 .depth = 8, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
174 }, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
175 [PIX_FMT_YUVJ444P] = { |
1204 | 176 .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
|
177 .color_type = FF_COLOR_YUV_JPEG, |
1204 | 178 .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
|
179 .depth = 8, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
180 }, |
5363 | 181 [PIX_FMT_YUVJ440P] = { |
182 .nb_channels = 3, | |
183 .color_type = FF_COLOR_YUV_JPEG, | |
184 .pixel_type = FF_PIXEL_PLANAR, | |
185 .depth = 8, | |
186 }, | |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
187 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
188 /* RGB formats */ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
189 [PIX_FMT_RGB24] = { |
1204 | 190 .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
|
191 .color_type = FF_COLOR_RGB, |
1204 | 192 .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
|
193 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
194 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
195 [PIX_FMT_BGR24] = { |
1204 | 196 .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
|
197 .color_type = FF_COLOR_RGB, |
1204 | 198 .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
|
199 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
200 }, |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
201 [PIX_FMT_ARGB] = { |
1204 | 202 .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
|
203 .color_type = FF_COLOR_RGB, |
1204 | 204 .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
|
205 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
206 }, |
9001 | 207 [PIX_FMT_RGB48BE] = { |
208 .nb_channels = 3, | |
209 .color_type = FF_COLOR_RGB, | |
210 .pixel_type = FF_PIXEL_PACKED, | |
211 .depth = 16, | |
212 }, | |
213 [PIX_FMT_RGB48LE] = { | |
214 .nb_channels = 3, | |
215 .color_type = FF_COLOR_RGB, | |
216 .pixel_type = FF_PIXEL_PACKED, | |
217 .depth = 16, | |
218 }, | |
9223
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
219 [PIX_FMT_RGB565BE] = { |
1204 | 220 .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
|
221 .color_type = FF_COLOR_RGB, |
1204 | 222 .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
|
223 .depth = 5, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
224 }, |
9223
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
225 [PIX_FMT_RGB565LE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
226 .nb_channels = 3, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
227 .color_type = FF_COLOR_RGB, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
228 .pixel_type = FF_PIXEL_PACKED, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
229 .depth = 5, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
230 }, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
231 [PIX_FMT_RGB555BE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
232 .nb_channels = 3, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
233 .color_type = FF_COLOR_RGB, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
234 .pixel_type = FF_PIXEL_PACKED, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
235 .depth = 5, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
236 }, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
237 [PIX_FMT_RGB555LE] = { |
4208 | 238 .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
|
239 .color_type = FF_COLOR_RGB, |
1204 | 240 .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
|
241 .depth = 5, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
242 }, |
11366 | 243 [PIX_FMT_RGB444BE] = { |
244 .nb_channels = 3, | |
245 .color_type = FF_COLOR_RGB, | |
246 .pixel_type = FF_PIXEL_PACKED, | |
247 .depth = 4, | |
248 }, | |
249 [PIX_FMT_RGB444LE] = { | |
250 .nb_channels = 3, | |
251 .color_type = FF_COLOR_RGB, | |
252 .pixel_type = FF_PIXEL_PACKED, | |
253 .depth = 4, | |
254 }, | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
255 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
256 /* gray / mono formats */ |
4066 | 257 [PIX_FMT_GRAY16BE] = { |
258 .nb_channels = 1, | |
259 .color_type = FF_COLOR_GRAY, | |
260 .pixel_type = FF_PIXEL_PLANAR, | |
261 .depth = 16, | |
262 }, | |
263 [PIX_FMT_GRAY16LE] = { | |
264 .nb_channels = 1, | |
265 .color_type = FF_COLOR_GRAY, | |
266 .pixel_type = FF_PIXEL_PLANAR, | |
267 .depth = 16, | |
268 }, | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
269 [PIX_FMT_GRAY8] = { |
1204 | 270 .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
|
271 .color_type = FF_COLOR_GRAY, |
1204 | 272 .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
|
273 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
274 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
275 [PIX_FMT_MONOWHITE] = { |
1204 | 276 .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
|
277 .color_type = FF_COLOR_GRAY, |
1204 | 278 .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
|
279 .depth = 1, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
280 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
281 [PIX_FMT_MONOBLACK] = { |
1204 | 282 .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
|
283 .color_type = FF_COLOR_GRAY, |
1204 | 284 .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
|
285 .depth = 1, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
286 }, |
1055 | 287 |
288 /* paletted formats */ | |
289 [PIX_FMT_PAL8] = { | |
1204 | 290 .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
|
291 .color_type = FF_COLOR_RGB, |
1204 | 292 .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
|
293 .depth = 8, |
1055 | 294 }, |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
295 [PIX_FMT_UYYVYY411] = { |
2309 | 296 .nb_channels = 1, |
297 .color_type = FF_COLOR_YUV, | |
298 .pixel_type = FF_PIXEL_PACKED, | |
299 .depth = 8, | |
300 }, | |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
301 [PIX_FMT_ABGR] = { |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
302 .nb_channels = 4, .is_alpha = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
303 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
304 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
305 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
306 }, |
9223
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
307 [PIX_FMT_BGR565BE] = { |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
308 .nb_channels = 3, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
309 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
310 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
311 .depth = 5, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
312 }, |
9223
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
313 [PIX_FMT_BGR565LE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
314 .nb_channels = 3, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
315 .color_type = FF_COLOR_RGB, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
316 .pixel_type = FF_PIXEL_PACKED, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
317 .depth = 5, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
318 }, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
319 [PIX_FMT_BGR555BE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
320 .nb_channels = 3, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
321 .color_type = FF_COLOR_RGB, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
322 .pixel_type = FF_PIXEL_PACKED, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
323 .depth = 5, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
324 }, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
325 [PIX_FMT_BGR555LE] = { |
4207
bc9de4875ebd
BGR555 has never been working as alpha supporting format. Remove the false setting.
alex
parents:
4201
diff
changeset
|
326 .nb_channels = 3, |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
327 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
328 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
329 .depth = 5, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
330 }, |
11366 | 331 [PIX_FMT_BGR444BE] = { |
332 .nb_channels = 3, | |
333 .color_type = FF_COLOR_RGB, | |
334 .pixel_type = FF_PIXEL_PACKED, | |
335 .depth = 4, | |
336 }, | |
337 [PIX_FMT_BGR444LE] = { | |
338 .nb_channels = 3, | |
339 .color_type = FF_COLOR_RGB, | |
340 .pixel_type = FF_PIXEL_PACKED, | |
341 .depth = 4, | |
342 }, | |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
343 [PIX_FMT_RGB8] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
344 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
345 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
346 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
347 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
348 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
349 [PIX_FMT_RGB4] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
350 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
351 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
352 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
353 .depth = 4, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
354 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
355 [PIX_FMT_RGB4_BYTE] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
356 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
357 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
358 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
359 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
360 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
361 [PIX_FMT_BGR8] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
362 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
363 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
364 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
365 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
366 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
367 [PIX_FMT_BGR4] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
368 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
369 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
370 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
371 .depth = 4, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
372 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
373 [PIX_FMT_BGR4_BYTE] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
374 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
375 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
376 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
377 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
378 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
379 [PIX_FMT_NV12] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
380 .nb_channels = 2, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
381 .color_type = FF_COLOR_YUV, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
382 .pixel_type = FF_PIXEL_PLANAR, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
383 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
384 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
385 [PIX_FMT_NV21] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
386 .nb_channels = 2, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
387 .color_type = FF_COLOR_YUV, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
388 .pixel_type = FF_PIXEL_PLANAR, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
389 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
390 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
391 |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
392 [PIX_FMT_BGRA] = { |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
393 .nb_channels = 4, .is_alpha = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
394 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
395 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
396 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
397 }, |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
398 [PIX_FMT_RGBA] = { |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
399 .nb_channels = 4, .is_alpha = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
400 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
401 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
402 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
403 }, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
404 }; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
405 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
406 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
|
407 { |
10573
ac49ab818d4d
Use av_pix_fmt_descriptors in avcodec_get_chroma_sub_sample(), rather
stefano
parents:
10572
diff
changeset
|
408 *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
|
409 *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
|
410 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
411 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
412 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
|
413 { |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
414 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
|
415 return NULL; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
416 else |
10579
dacdec913c5b
Make avcodec_get_pix_fmt_name() use av_pix_fmt_descriptors rather than
stefano
parents:
10577
diff
changeset
|
417 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
|
418 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
419 |
11059
e1bc53867092
Implement av_get_pix_fmt(), and deprecate avcodec_get_pix_fmt().
stefano
parents:
10682
diff
changeset
|
420 #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
|
421 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
|
422 { |
11059
e1bc53867092
Implement av_get_pix_fmt(), and deprecate avcodec_get_pix_fmt().
stefano
parents:
10682
diff
changeset
|
423 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
|
424 } |
11059
e1bc53867092
Implement av_get_pix_fmt(), and deprecate avcodec_get_pix_fmt().
stefano
parents:
10682
diff
changeset
|
425 #endif |
9222
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
426 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
427 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
|
428 { |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
429 /* print header */ |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
430 if (pix_fmt < 0) |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
431 snprintf (buf, buf_size, |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
432 "name " " nb_channels" " depth" " is_alpha" |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
433 ); |
6911 | 434 else{ |
435 PixFmtInfo info= pix_fmt_info[pix_fmt]; | |
436 | |
437 char is_alpha_char= info.is_alpha ? 'y' : 'n'; | |
438 | |
5084
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
439 snprintf (buf, buf_size, |
10277 | 440 "%-11s %5d %9d %6c", |
10583
96d1d05cfd37
Use pixel formats names defined in av_pix_fmt_descriptors rather than
stefano
parents:
10582
diff
changeset
|
441 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
|
442 info.nb_channels, |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
443 info.depth, |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
444 is_alpha_char |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
445 ); |
6911 | 446 } |
5084
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
447 } |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
448 |
9011
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
449 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
|
450 { |
10572
a21b640dba50
Use av_pix_fmt_descriptors in ff_is_hwaccel_pix_fmt() rather than
stefano
parents:
10569
diff
changeset
|
451 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
|
452 } |
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
453 |
8748
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
454 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
|
455 int i; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
456 |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
457 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
|
458 int r,g,b; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
459 |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
460 switch(pix_fmt) { |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
461 case PIX_FMT_RGB8: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
462 r= (i>>5 )*36; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
463 g= ((i>>2)&7)*36; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
464 b= (i&3 )*85; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
465 break; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
466 case PIX_FMT_BGR8: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
467 b= (i>>6 )*85; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
468 g= ((i>>3)&7)*36; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
469 r= (i&7 )*36; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
470 break; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
471 case PIX_FMT_RGB4_BYTE: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
472 r= (i>>3 )*255; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
473 g= ((i>>1)&3)*85; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
474 b= (i&1 )*255; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
475 break; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
476 case PIX_FMT_BGR4_BYTE: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
477 b= (i>>3 )*255; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
478 g= ((i>>1)&3)*85; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
479 r= (i&1 )*255; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
480 break; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
481 case PIX_FMT_GRAY8: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
482 r=b=g= i; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
483 break; |
8788
5e9e735cd793
Add a default (error) for the switch in case of an unsupported PIX_FMT.
gpoirier
parents:
8748
diff
changeset
|
484 default: |
5e9e735cd793
Add a default (error) for the switch in case of an unsupported PIX_FMT.
gpoirier
parents:
8748
diff
changeset
|
485 return -1; |
8748
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
486 } |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
487 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
|
488 } |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
489 |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
490 return 0; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
491 } |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
492 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
493 int ff_fill_linesize(AVPicture *picture, enum PixelFormat pix_fmt, int width) |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
494 { |
11598
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
495 int i; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
496 const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt]; |
11598
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
497 int max_plane_step [4]; |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
498 int max_plane_step_comp[4]; |
2967 | 499 |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
500 memset(picture->linesize, 0, sizeof(picture->linesize)); |
2422 | 501 |
11598
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
502 if (desc->flags & PIX_FMT_HWACCEL) |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
503 return -1; |
11598
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
504 |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
505 if (desc->flags & PIX_FMT_BITSTREAM) { |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
506 picture->linesize[0] = (width * (desc->comp[0].step_minus1+1) + 7) >> 3; |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
507 return 0; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
508 } |
11598
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
509 |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
510 memset(max_plane_step , 0, sizeof(max_plane_step )); |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
511 memset(max_plane_step_comp, 0, sizeof(max_plane_step_comp)); |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
512 for (i = 0; i < 4; i++) { |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
513 const AVComponentDescriptor *comp = &(desc->comp[i]); |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
514 if ((comp->step_minus1+1) > max_plane_step[comp->plane]) { |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
515 max_plane_step [comp->plane] = comp->step_minus1+1; |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
516 max_plane_step_comp[comp->plane] = i; |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
517 } |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
518 } |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
519 |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
520 for (i = 0; i < 4; i++) { |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
521 int s = (max_plane_step_comp[i] == 1 || max_plane_step_comp[i] == 2) ? desc->log2_chroma_w : 0; |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
522 picture->linesize[i] = max_plane_step[i] * (((width + (1 << s) - 1)) >> s); |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
523 } |
0124d6beb415
Make ff_fill_linesize() use the information stored in
stefano
parents:
11367
diff
changeset
|
524 |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
525 return 0; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
526 } |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
527 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
528 int ff_fill_pointer(AVPicture *picture, uint8_t *ptr, enum PixelFormat pix_fmt, |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
529 int height) |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
530 { |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
531 int size, h2, size2; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
532 const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt]; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
533 |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
534 size = picture->linesize[0] * height; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
535 switch(pix_fmt) { |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
536 case PIX_FMT_YUV420P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
537 case PIX_FMT_YUV422P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
538 case PIX_FMT_YUV444P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
539 case PIX_FMT_YUV410P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
540 case PIX_FMT_YUV411P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
541 case PIX_FMT_YUV440P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
542 case PIX_FMT_YUVJ420P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
543 case PIX_FMT_YUVJ422P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
544 case PIX_FMT_YUVJ444P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
545 case PIX_FMT_YUVJ440P: |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
546 case PIX_FMT_YUV420P16LE: |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
547 case PIX_FMT_YUV422P16LE: |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
548 case PIX_FMT_YUV444P16LE: |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
549 case PIX_FMT_YUV420P16BE: |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
550 case PIX_FMT_YUV422P16BE: |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
551 case PIX_FMT_YUV444P16BE: |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
552 h2 = (height + (1 << desc->log2_chroma_h) - 1) >> desc->log2_chroma_h; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
553 size2 = picture->linesize[1] * h2; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
554 picture->data[0] = ptr; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
555 picture->data[1] = picture->data[0] + size; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
556 picture->data[2] = picture->data[1] + size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
557 picture->data[3] = NULL; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
558 return size + 2 * size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
559 case PIX_FMT_YUVA420P: |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
560 h2 = (height + (1 << desc->log2_chroma_h) - 1) >> desc->log2_chroma_h; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
561 size2 = picture->linesize[1] * h2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
562 picture->data[0] = ptr; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
563 picture->data[1] = picture->data[0] + size; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
564 picture->data[2] = picture->data[1] + size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
565 picture->data[3] = picture->data[1] + size2 + size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
566 return 2 * size + 2 * size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
567 case PIX_FMT_NV12: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
568 case PIX_FMT_NV21: |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
569 h2 = (height + (1 << desc->log2_chroma_h) - 1) >> desc->log2_chroma_h; |
10569
7a8b35405591
Fix nv12/nv21 handling. linesize for plane 1 should account for both chroma
ramiro
parents:
10546
diff
changeset
|
570 size2 = picture->linesize[1] * h2; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
571 picture->data[0] = ptr; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
572 picture->data[1] = picture->data[0] + size; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
573 picture->data[2] = NULL; |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
574 picture->data[3] = NULL; |
10569
7a8b35405591
Fix nv12/nv21 handling. linesize for plane 1 should account for both chroma
ramiro
parents:
10546
diff
changeset
|
575 return size + size2; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
576 case PIX_FMT_RGB24: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
577 case PIX_FMT_BGR24: |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
578 case PIX_FMT_ARGB: |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
579 case PIX_FMT_ABGR: |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
580 case PIX_FMT_RGBA: |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
581 case PIX_FMT_BGRA: |
9001 | 582 case PIX_FMT_RGB48BE: |
583 case PIX_FMT_RGB48LE: | |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
584 case PIX_FMT_GRAY16BE: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
585 case PIX_FMT_GRAY16LE: |
11366 | 586 case PIX_FMT_BGR444BE: |
587 case PIX_FMT_BGR444LE: | |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
588 case PIX_FMT_BGR555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
589 case PIX_FMT_BGR555LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
590 case PIX_FMT_BGR565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
591 case PIX_FMT_BGR565LE: |
11366 | 592 case PIX_FMT_RGB444BE: |
593 case PIX_FMT_RGB444LE: | |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
594 case PIX_FMT_RGB555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
595 case PIX_FMT_RGB555LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
596 case PIX_FMT_RGB565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
597 case PIX_FMT_RGB565LE: |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
598 case PIX_FMT_YUYV422: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
599 case PIX_FMT_UYVY422: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
600 case PIX_FMT_UYYVYY411: |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
601 case PIX_FMT_RGB4: |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
602 case PIX_FMT_BGR4: |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
603 case PIX_FMT_MONOWHITE: |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
604 case PIX_FMT_MONOBLACK: |
11630 | 605 case PIX_FMT_Y400A: |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
606 picture->data[0] = ptr; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
607 picture->data[1] = NULL; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
608 picture->data[2] = NULL; |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
609 picture->data[3] = NULL; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
610 return size; |
1055 | 611 case PIX_FMT_PAL8: |
8748
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
612 case PIX_FMT_RGB8: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
613 case PIX_FMT_BGR8: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
614 case PIX_FMT_RGB4_BYTE: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
615 case PIX_FMT_BGR4_BYTE: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
616 case PIX_FMT_GRAY8: |
1055 | 617 size2 = (size + 3) & ~3; |
618 picture->data[0] = ptr; | |
619 picture->data[1] = ptr + size2; /* palette is stored here as 256 32 bit words */ | |
620 picture->data[2] = NULL; | |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
621 picture->data[3] = NULL; |
1055 | 622 return size2 + 256 * 4; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
623 default: |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
624 picture->data[0] = NULL; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
625 picture->data[1] = NULL; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
626 picture->data[2] = NULL; |
1055 | 627 picture->data[3] = NULL; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
628 return -1; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
629 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
630 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
631 |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
632 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
|
633 enum PixelFormat pix_fmt, int width, int height) |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
634 { |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
635 |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
636 if(avcodec_check_dimensions(NULL, width, height)) |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
637 return -1; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
638 |
6357 | 639 if (ff_fill_linesize(picture, pix_fmt, width)) |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
640 return -1; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
641 |
6357 | 642 return ff_fill_pointer(picture, ptr, pix_fmt, height); |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
643 } |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
644 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
645 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
|
646 unsigned char *dest, int dest_size) |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
647 { |
3420 | 648 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
|
649 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
|
650 int i, j, w, ow, h, oh, data_planes; |
2967 | 651 const unsigned char* s; |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
652 int size = avpicture_get_size(pix_fmt, width, height); |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
653 |
2422 | 654 if (size > dest_size || size < 0) |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
655 return -1; |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
656 |
1243
5d2376294fbf
* fixing a bug in avpicture_layout (PAL8 wasn't handled properly)
romansh
parents:
1231
diff
changeset
|
657 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
|
658 if (pix_fmt == PIX_FMT_YUYV422 || |
2967 | 659 pix_fmt == PIX_FMT_UYVY422 || |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
660 pix_fmt == PIX_FMT_BGR565BE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
661 pix_fmt == PIX_FMT_BGR565LE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
662 pix_fmt == PIX_FMT_BGR555BE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
663 pix_fmt == PIX_FMT_BGR555LE || |
11366 | 664 pix_fmt == PIX_FMT_BGR444BE || |
665 pix_fmt == PIX_FMT_BGR444LE || | |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
666 pix_fmt == PIX_FMT_RGB565BE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
667 pix_fmt == PIX_FMT_RGB565LE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
668 pix_fmt == PIX_FMT_RGB555BE || |
11366 | 669 pix_fmt == PIX_FMT_RGB555LE || |
670 pix_fmt == PIX_FMT_RGB444BE || | |
671 pix_fmt == PIX_FMT_RGB444LE) | |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
672 w = width * 2; |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
673 else if (pix_fmt == PIX_FMT_UYYVYY411) |
10546 | 674 w = width + width/2; |
2979 | 675 else if (pix_fmt == PIX_FMT_PAL8) |
10546 | 676 w = width; |
2979 | 677 else |
10546 | 678 w = width * (pf->depth * pf->nb_channels / 8); |
2967 | 679 |
2979 | 680 data_planes = 1; |
681 h = height; | |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
682 } else { |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
683 data_planes = pf->nb_channels; |
2979 | 684 w = (width*pf->depth + 7)/8; |
685 h = height; | |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
686 } |
2967 | 687 |
9070
87f496299f09
Fix avpicture_layout to not chroma shift the alpha plane when outputting YUVA420P
sdrik
parents:
9061
diff
changeset
|
688 ow = w; |
87f496299f09
Fix avpicture_layout to not chroma shift the alpha plane when outputting YUVA420P
sdrik
parents:
9061
diff
changeset
|
689 oh = h; |
87f496299f09
Fix avpicture_layout to not chroma shift the alpha plane when outputting YUVA420P
sdrik
parents:
9061
diff
changeset
|
690 |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
691 for (i=0; i<data_planes; i++) { |
10546 | 692 if (i == 1) { |
11367 | 693 w = (- ((-width) >> desc->log2_chroma_w) * pf->depth + 7) / 8; |
694 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
|
695 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
|
696 w <<= 1; |
10546 | 697 } else if (i == 3) { |
698 w = ow; | |
699 h = oh; | |
700 } | |
701 s = src->data[i]; | |
702 for(j=0; j<h; j++) { | |
703 memcpy(dest, s, w); | |
704 dest += w; | |
705 s += src->linesize[i]; | |
706 } | |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
707 } |
2967 | 708 |
1243
5d2376294fbf
* fixing a bug in avpicture_layout (PAL8 wasn't handled properly)
romansh
parents:
1231
diff
changeset
|
709 if (pf->pixel_type == FF_PIXEL_PALETTE) |
2979 | 710 memcpy((unsigned char *)(((size_t)dest + 3) & ~3), src->data[1], 256 * 4); |
2967 | 711 |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
712 return size; |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
713 } |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
714 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
715 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
|
716 { |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
717 AVPicture dummy_pict; |
9217
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
718 if(avcodec_check_dimensions(NULL, width, height)) |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
719 return -1; |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
720 switch (pix_fmt) { |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
721 case PIX_FMT_RGB8: |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
722 case PIX_FMT_BGR8: |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
723 case PIX_FMT_RGB4_BYTE: |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
724 case PIX_FMT_BGR4_BYTE: |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
725 case PIX_FMT_GRAY8: |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
726 // 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
|
727 return width * height; |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
728 } |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
729 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
|
730 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
731 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
732 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
|
733 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
|
734 { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
735 const PixFmtInfo *pf, *ps; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
736 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
|
737 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
|
738 int loss; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
739 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
740 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
|
741 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
742 /* compute loss */ |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
743 loss = 0; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
744 pf = &pix_fmt_info[dst_pix_fmt]; |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
745 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
|
746 ((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
|
747 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
|
748 (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
|
749 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
|
750 loss |= FF_LOSS_DEPTH; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
751 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
|
752 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
|
753 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
|
754 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
|
755 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
|
756 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
|
757 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
|
758 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
|
759 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
760 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
|
761 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
|
762 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
|
763 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
764 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
|
765 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
|
766 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
|
767 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
768 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
|
769 if (ps->color_type != FF_COLOR_YUV_JPEG && |
2967 | 770 ps->color_type != FF_COLOR_YUV && |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
771 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
|
772 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
|
773 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
774 default: |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
775 /* 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
|
776 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
|
777 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
|
778 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
779 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
780 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
|
781 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
|
782 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
|
783 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
|
784 loss |= FF_LOSS_ALPHA; |
2967 | 785 if (pf->pixel_type == FF_PIXEL_PALETTE && |
1204 | 786 (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
|
787 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
|
788 return loss; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
789 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
790 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
791 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
|
792 { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
793 int bits; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
794 const PixFmtInfo *pf; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
795 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
|
796 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
797 pf = &pix_fmt_info[pix_fmt]; |
1204 | 798 switch(pf->pixel_type) { |
799 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
|
800 switch(pix_fmt) { |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
801 case PIX_FMT_YUYV422: |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
802 case PIX_FMT_UYVY422: |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
803 case PIX_FMT_RGB565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
804 case PIX_FMT_RGB565LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
805 case PIX_FMT_RGB555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
806 case PIX_FMT_RGB555LE: |
11366 | 807 case PIX_FMT_RGB444BE: |
808 case PIX_FMT_RGB444LE: | |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
809 case PIX_FMT_BGR565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
810 case PIX_FMT_BGR565LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
811 case PIX_FMT_BGR555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
812 case PIX_FMT_BGR555LE: |
11366 | 813 case PIX_FMT_BGR444BE: |
814 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
|
815 bits = 16; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
816 break; |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
817 case PIX_FMT_UYYVYY411: |
2979 | 818 bits = 12; |
819 break; | |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
820 default: |
1204 | 821 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
|
822 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
823 } |
1204 | 824 break; |
825 case FF_PIXEL_PLANAR: | |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
826 if (desc->log2_chroma_w == 0 && desc->log2_chroma_h == 0) { |
1204 | 827 bits = pf->depth * pf->nb_channels; |
828 } else { | |
2967 | 829 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
|
830 (desc->log2_chroma_w + desc->log2_chroma_h)); |
1204 | 831 } |
832 break; | |
833 case FF_PIXEL_PALETTE: | |
834 bits = 8; | |
835 break; | |
836 default: | |
837 bits = -1; | |
838 break; | |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
839 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
840 return bits; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
841 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
842 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
843 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
|
844 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
|
845 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
|
846 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
|
847 { |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
848 int dist, i, loss, min_dist; |
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
849 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
|
850 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
851 /* 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
|
852 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
|
853 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
|
854 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
|
855 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
|
856 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
|
857 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
|
858 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
|
859 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
|
860 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
|
861 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
|
862 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
863 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
864 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
865 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
866 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
|
867 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
868 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
869 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
|
870 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
|
871 { |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
872 enum PixelFormat dst_pix_fmt; |
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
873 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
|
874 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
|
875 ~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
|
876 ~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
|
877 ~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
|
878 ~(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
|
879 ~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
|
880 ~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
|
881 0, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
882 }; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
883 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
884 /* 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
|
885 i = 0; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
886 for(;;) { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
887 loss_mask = loss_mask_order[i++]; |
2967 | 888 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
|
889 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
|
890 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
|
891 goto found; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
892 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
|
893 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
894 } |
10682
aa8bebc96764
Use PIX_FMT_NONE for -1 when enum PixelFormat is expected (fixes two icc warnings).
cehoyos
parents:
10640
diff
changeset
|
895 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
|
896 found: |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
897 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
|
898 *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
|
899 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
|
900 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
901 |
3245 | 902 void ff_img_copy_plane(uint8_t *dst, int dst_wrap, |
1205 | 903 const uint8_t *src, int src_wrap, |
904 int width, int height) | |
1204 | 905 { |
2967 | 906 if((!dst) || (!src)) |
2785 | 907 return; |
1204 | 908 for(;height > 0; height--) { |
909 memcpy(dst, src, width); | |
910 dst += dst_wrap; | |
911 src += src_wrap; | |
912 } | |
913 } | |
914 | |
6358 | 915 int ff_get_plane_bytewidth(enum PixelFormat pix_fmt, int width, int plane) |
1204 | 916 { |
6347 | 917 int bits; |
3420 | 918 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
|
919 const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt]; |
2967 | 920 |
1204 | 921 pf = &pix_fmt_info[pix_fmt]; |
922 switch(pf->pixel_type) { | |
923 case FF_PIXEL_PACKED: | |
924 switch(pix_fmt) { | |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
925 case PIX_FMT_YUYV422: |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
926 case PIX_FMT_UYVY422: |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
927 case PIX_FMT_RGB565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
928 case PIX_FMT_RGB565LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
929 case PIX_FMT_RGB555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
930 case PIX_FMT_RGB555LE: |
11366 | 931 case PIX_FMT_RGB444BE: |
932 case PIX_FMT_RGB444LE: | |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
933 case PIX_FMT_BGR565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
934 case PIX_FMT_BGR565LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
935 case PIX_FMT_BGR555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
936 case PIX_FMT_BGR555LE: |
11366 | 937 case PIX_FMT_BGR444BE: |
938 case PIX_FMT_BGR444LE: | |
1204 | 939 bits = 16; |
940 break; | |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
941 case PIX_FMT_UYYVYY411: |
2979 | 942 bits = 12; |
943 break; | |
1204 | 944 default: |
945 bits = pf->depth * pf->nb_channels; | |
946 break; | |
947 } | |
6347 | 948 return (width * bits + 7) >> 3; |
949 break; | |
950 case FF_PIXEL_PLANAR: | |
11842
3c812305443b
Fix width computation for nv12/nv21 in ff_get_plane_bytewidth().
stefano
parents:
11644
diff
changeset
|
951 if ((pix_fmt != PIX_FMT_NV12 && pix_fmt != PIX_FMT_NV21) && |
3c812305443b
Fix width computation for nv12/nv21 in ff_get_plane_bytewidth().
stefano
parents:
11644
diff
changeset
|
952 (plane == 1 || plane == 2)) |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
953 width= -((-width)>>desc->log2_chroma_w); |
6347 | 954 |
955 return (width * pf->depth + 7) >> 3; | |
956 break; | |
957 case FF_PIXEL_PALETTE: | |
958 if (plane == 0) | |
959 return width; | |
1204 | 960 break; |
6347 | 961 } |
962 | |
963 return -1; | |
964 } | |
965 | |
966 void av_picture_copy(AVPicture *dst, const AVPicture *src, | |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
967 enum PixelFormat pix_fmt, int width, int height) |
6347 | 968 { |
969 int i; | |
970 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
|
971 const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt]; |
6347 | 972 |
973 switch(pf->pixel_type) { | |
974 case FF_PIXEL_PACKED: | |
1204 | 975 case FF_PIXEL_PLANAR: |
976 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
|
977 int h; |
6358 | 978 int bwidth = ff_get_plane_bytewidth(pix_fmt, width, i); |
1204 | 979 h = height; |
980 if (i == 1 || i == 2) { | |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
981 h= -((-height)>>desc->log2_chroma_h); |
1204 | 982 } |
3245 | 983 ff_img_copy_plane(dst->data[i], dst->linesize[i], |
1204 | 984 src->data[i], src->linesize[i], |
985 bwidth, h); | |
986 } | |
987 break; | |
988 case FF_PIXEL_PALETTE: | |
3245 | 989 ff_img_copy_plane(dst->data[0], dst->linesize[0], |
1204 | 990 src->data[0], src->linesize[0], |
991 width, height); | |
992 /* copy the palette */ | |
10510
26fcf45bb486
Fix palette copying in av_picture_copy(). Previous code worked only if
vitor
parents:
10509
diff
changeset
|
993 memcpy(dst->data[1], src->data[1], 4*256); |
1204 | 994 break; |
995 } | |
996 } | |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
997 |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
998 /* 2x2 -> 1x1 */ |
3245 | 999 void ff_shrink22(uint8_t *dst, int dst_wrap, |
1205 | 1000 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
|
1001 int width, int height) |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1002 { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1003 int w; |
1205 | 1004 const uint8_t *s1, *s2; |
1005 uint8_t *d; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1006 |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1007 for(;height > 0; height--) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1008 s1 = src; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1009 s2 = s1 + src_wrap; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1010 d = dst; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1011 for(w = width;w >= 4; w-=4) { |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
1012 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
|
1013 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
|
1014 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
|
1015 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
|
1016 s1 += 8; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1017 s2 += 8; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1018 d += 4; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1019 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1020 for(;w > 0; w--) { |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
1021 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
|
1022 s1 += 2; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1023 s2 += 2; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1024 d++; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1025 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1026 src += 2 * src_wrap; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1027 dst += dst_wrap; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1028 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1029 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1030 |
1205 | 1031 /* 4x4 -> 1x1 */ |
3245 | 1032 void ff_shrink44(uint8_t *dst, int dst_wrap, |
1205 | 1033 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
|
1034 int width, int height) |
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1035 { |
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1036 int w; |
1205 | 1037 const uint8_t *s1, *s2, *s3, *s4; |
1038 uint8_t *d; | |
576
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1039 |
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1040 for(;height > 0; height--) { |
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1041 s1 = src; |
1205 | 1042 s2 = s1 + src_wrap; |
1043 s3 = s2 + src_wrap; | |
1044 s4 = s3 + src_wrap; | |
576
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1045 d = dst; |
1205 | 1046 for(w = width;w > 0; w--) { |
1047 d[0] = (s1[0] + s1[1] + s1[2] + s1[3] + | |
1048 s2[0] + s2[1] + s2[2] + s2[3] + | |
1049 s3[0] + s3[1] + s3[2] + s3[3] + | |
1050 s4[0] + s4[1] + s4[2] + s4[3] + 8) >> 4; | |
1051 s1 += 4; | |
1052 s2 += 4; | |
1053 s3 += 4; | |
1054 s4 += 4; | |
576
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1055 d++; |
9aa5f0d0124e
YUV410P to YUV420P patch by Fran«®ois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1056 } |
1205 | 1057 src += 4 * src_wrap; |
1058 dst += dst_wrap; | |
1059 } | |
1060 } | |
1061 | |
3245 | 1062 /* 8x8 -> 1x1 */ |
1063 void ff_shrink88(uint8_t *dst, int dst_wrap, | |
1064 const uint8_t *src, int src_wrap, | |
1065 int width, int height) | |
1066 { | |
1067 int w, i; | |
1068 | |
1069 for(;height > 0; height--) { | |
1070 for(w = width;w > 0; w--) { | |
1071 int tmp=0; | |
1072 for(i=0; i<8; i++){ | |
1073 tmp += src[0] + src[1] + src[2] + src[3] + src[4] + src[5] + src[6] + src[7]; | |
1074 src += src_wrap; | |
1075 } | |
1076 *(dst++) = (tmp + 32)>>6; | |
1077 src += 8 - 8*src_wrap; | |
1078 } | |
1079 src += 8*src_wrap - 8*width; | |
1080 dst += dst_wrap - width; | |
1081 } | |
1082 } | |
1083 | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1084 |
1508 | 1085 int avpicture_alloc(AVPicture *picture, |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
1086 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
|
1087 { |
3266
3b785e80ce3e
make "size" variable in avpicture_alloc signed, since avpicture_get_size
reimar
parents:
3257
diff
changeset
|
1088 int size; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1089 void *ptr; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1090 |
9217
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
1091 size = avpicture_fill(picture, NULL, pix_fmt, width, height); |
2422 | 1092 if(size<0) |
1093 goto fail; | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1094 ptr = av_malloc(size); |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1095 if (!ptr) |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1096 goto fail; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1097 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
|
1098 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
|
1099 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
|
1100 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1101 return 0; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1102 fail: |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1103 memset(picture, 0, sizeof(AVPicture)); |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1104 return -1; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1105 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1106 |
1508 | 1107 void avpicture_free(AVPicture *picture) |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1108 { |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
1028
diff
changeset
|
1109 av_free(picture->data[0]); |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1110 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1111 |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1112 /* return true if yuv planar */ |
3420 | 1113 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
|
1114 { |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1115 return (ps->color_type == FF_COLOR_YUV || |
2967 | 1116 ps->color_type == FF_COLOR_YUV_JPEG) && |
1204 | 1117 ps->pixel_type == FF_PIXEL_PLANAR; |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1118 } |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1119 |
4624
6a900f539e2c
Add the prefix "av_" to img_crop(), img_copy() and img_pad(), and rename "img"
takis
parents:
4593
diff
changeset
|
1120 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
|
1121 enum PixelFormat pix_fmt, int top_band, int left_band) |
3179 | 1122 { |
1123 int y_shift; | |
1124 int x_shift; | |
1125 | |
1126 if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB || !is_yuv_planar(&pix_fmt_info[pix_fmt])) | |
1127 return -1; | |
1128 | |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
1129 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
|
1130 x_shift = av_pix_fmt_descriptors[pix_fmt].log2_chroma_w; |
3179 | 1131 |
1132 dst->data[0] = src->data[0] + (top_band * src->linesize[0]) + left_band; | |
1133 dst->data[1] = src->data[1] + ((top_band >> y_shift) * src->linesize[1]) + (left_band >> x_shift); | |
1134 dst->data[2] = src->data[2] + ((top_band >> y_shift) * src->linesize[2]) + (left_band >> x_shift); | |
1135 | |
1136 dst->linesize[0] = src->linesize[0]; | |
1137 dst->linesize[1] = src->linesize[1]; | |
1138 dst->linesize[2] = src->linesize[2]; | |
1139 return 0; | |
1140 } | |
1141 | |
4624
6a900f539e2c
Add the prefix "av_" to img_crop(), img_copy() and img_pad(), and rename "img"
takis
parents:
4593
diff
changeset
|
1142 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
|
1143 enum PixelFormat pix_fmt, int padtop, int padbottom, int padleft, int padright, |
4358 | 1144 int *color) |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1145 { |
4359
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1146 uint8_t *optr; |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1147 int y_shift; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1148 int x_shift; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1149 int yheight; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1150 int i, y; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1151 |
4358 | 1152 if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB || |
1153 !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
|
1154 |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1155 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
|
1156 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
|
1157 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
|
1158 |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1159 if (padtop || padleft) { |
4358 | 1160 memset(dst->data[i], color[i], |
1161 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
|
1162 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1163 |
4359
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1164 if (padleft || padright) { |
4358 | 1165 optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) + |
1166 (dst->linesize[i] - (padright >> x_shift)); | |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1167 yheight = (height - 1 - (padtop + padbottom)) >> y_shift; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1168 for (y = 0; y < yheight; y++) { |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1169 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
|
1170 optr += dst->linesize[i]; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1171 } |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1172 } |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1173 |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1174 if (src) { /* first line */ |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1175 uint8_t *iptr = src->data[i]; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1176 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
|
1177 (padleft >> x_shift); |
6963
cc2c5a21a0eb
memcpy considering output width, not src linesize, fix segv with av_picture_pad
bcoudurier
parents:
6911
diff
changeset
|
1178 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
|
1179 iptr += src->linesize[i]; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1180 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
|
1181 (dst->linesize[i] - (padright >> x_shift)); |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1182 yheight = (height - 1 - (padtop + padbottom)) >> y_shift; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1183 for (y = 0; y < yheight; y++) { |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1184 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
|
1185 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
|
1186 (width - padleft - padright) >> x_shift); |
4359
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1187 iptr += src->linesize[i]; |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1188 optr += dst->linesize[i]; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1189 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1190 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1191 |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1192 if (padbottom || padright) { |
4358 | 1193 optr = dst->data[i] + dst->linesize[i] * |
1194 ((height - padbottom) >> y_shift) - (padright >> x_shift); | |
1195 memset(optr, color[i],dst->linesize[i] * | |
1196 (padbottom >> y_shift) + (padright >> x_shift)); | |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1197 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1198 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1199 return 0; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1200 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1201 |
1208 | 1202 /* 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
|
1203 static int get_alpha_info_pal8(const AVPicture *src, int width, int height) |
1208 | 1204 { |
1205 const unsigned char *p; | |
1206 int src_wrap, ret, x, y; | |
1207 unsigned int a; | |
1208 uint32_t *palette = (uint32_t *)src->data[1]; | |
2967 | 1209 |
1208 | 1210 p = src->data[0]; |
1211 src_wrap = src->linesize[0] - width; | |
1212 ret = 0; | |
1213 for(y=0;y<height;y++) { | |
1214 for(x=0;x<width;x++) { | |
1215 a = palette[p[0]] >> 24; | |
1216 if (a == 0x00) { | |
1217 ret |= FF_ALPHA_TRANSP; | |
1218 } else if (a != 0xff) { | |
1219 ret |= FF_ALPHA_SEMI_TRANSP; | |
1220 } | |
1221 p++; | |
1222 } | |
1223 p += src_wrap; | |
1224 } | |
1225 return ret; | |
1226 } | |
1227 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1228 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
|
1229 enum PixelFormat pix_fmt, int width, int height) |
1208 | 1230 { |
3420 | 1231 const PixFmtInfo *pf = &pix_fmt_info[pix_fmt]; |
1208 | 1232 int ret; |
1233 | |
1234 /* no alpha can be represented in format */ | |
1235 if (!pf->is_alpha) | |
1236 return 0; | |
1237 switch(pix_fmt) { | |
1238 case PIX_FMT_PAL8: | |
1239 ret = get_alpha_info_pal8(src, width, height); | |
1240 break; | |
1241 default: | |
1242 /* we do not know, so everything is indicated */ | |
1243 ret = FF_ALPHA_TRANSP | FF_ALPHA_SEMI_TRANSP; | |
1244 break; | |
1245 } | |
1246 return ret; | |
1247 } | |
801 | 1248 |
8590 | 1249 #if HAVE_MMX |
801 | 1250 #define DEINT_INPLACE_LINE_LUM \ |
1251 movd_m2r(lum_m4[0],mm0);\ | |
1252 movd_m2r(lum_m3[0],mm1);\ | |
1253 movd_m2r(lum_m2[0],mm2);\ | |
1254 movd_m2r(lum_m1[0],mm3);\ | |
1255 movd_m2r(lum[0],mm4);\ | |
1256 punpcklbw_r2r(mm7,mm0);\ | |
1257 movd_r2m(mm2,lum_m4[0]);\ | |
1258 punpcklbw_r2r(mm7,mm1);\ | |
1259 punpcklbw_r2r(mm7,mm2);\ | |
1260 punpcklbw_r2r(mm7,mm3);\ | |
1261 punpcklbw_r2r(mm7,mm4);\ | |
1262 paddw_r2r(mm3,mm1);\ | |
1263 psllw_i2r(1,mm2);\ | |
1264 paddw_r2r(mm4,mm0);\ | |
1265 psllw_i2r(2,mm1);\ | |
1266 paddw_r2r(mm6,mm2);\ | |
1267 paddw_r2r(mm2,mm1);\ | |
1268 psubusw_r2r(mm0,mm1);\ | |
1269 psrlw_i2r(3,mm1);\ | |
1270 packuswb_r2r(mm7,mm1);\ | |
1271 movd_r2m(mm1,lum_m2[0]); | |
1272 | |
1273 #define DEINT_LINE_LUM \ | |
1274 movd_m2r(lum_m4[0],mm0);\ | |
1275 movd_m2r(lum_m3[0],mm1);\ | |
1276 movd_m2r(lum_m2[0],mm2);\ | |
1277 movd_m2r(lum_m1[0],mm3);\ | |
1278 movd_m2r(lum[0],mm4);\ | |
1279 punpcklbw_r2r(mm7,mm0);\ | |
1280 punpcklbw_r2r(mm7,mm1);\ | |
1281 punpcklbw_r2r(mm7,mm2);\ | |
1282 punpcklbw_r2r(mm7,mm3);\ | |
1283 punpcklbw_r2r(mm7,mm4);\ | |
1284 paddw_r2r(mm3,mm1);\ | |
1285 psllw_i2r(1,mm2);\ | |
1286 paddw_r2r(mm4,mm0);\ | |
1287 psllw_i2r(2,mm1);\ | |
1288 paddw_r2r(mm6,mm2);\ | |
1289 paddw_r2r(mm2,mm1);\ | |
1290 psubusw_r2r(mm0,mm1);\ | |
1291 psrlw_i2r(3,mm1);\ | |
1292 packuswb_r2r(mm7,mm1);\ | |
1293 movd_r2m(mm1,dst[0]); | |
1294 #endif | |
1295 | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1296 /* filter parameters: [-1 4 2 4 -1] // 8 */ |
2967 | 1297 static void deinterlace_line(uint8_t *dst, |
2979 | 1298 const uint8_t *lum_m4, const uint8_t *lum_m3, |
1299 const uint8_t *lum_m2, const uint8_t *lum_m1, | |
1300 const uint8_t *lum, | |
1301 int size) | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1302 { |
8590 | 1303 #if !HAVE_MMX |
4176 | 1304 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
|
1305 int sum; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1306 |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1307 for(;size > 0;size--) { |
801 | 1308 sum = -lum_m4[0]; |
1309 sum += lum_m3[0] << 2; | |
1310 sum += lum_m2[0] << 1; | |
1311 sum += lum_m1[0] << 2; | |
1312 sum += -lum[0]; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1313 dst[0] = cm[(sum + 4) >> 3]; |
801 | 1314 lum_m4++; |
1315 lum_m3++; | |
1316 lum_m2++; | |
1317 lum_m1++; | |
1318 lum++; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1319 dst++; |
801 | 1320 } |
1321 #else | |
1322 | |
1044 | 1323 { |
1324 pxor_r2r(mm7,mm7); | |
8316 | 1325 movq_m2r(ff_pw_4,mm6); |
1044 | 1326 } |
801 | 1327 for (;size > 3; size-=4) { |
1328 DEINT_LINE_LUM | |
1329 lum_m4+=4; | |
1330 lum_m3+=4; | |
1331 lum_m2+=4; | |
1332 lum_m1+=4; | |
1333 lum+=4; | |
1334 dst+=4; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1335 } |
801 | 1336 #endif |
1337 } | |
1064 | 1338 static void deinterlace_line_inplace(uint8_t *lum_m4, uint8_t *lum_m3, uint8_t *lum_m2, uint8_t *lum_m1, uint8_t *lum, |
801 | 1339 int size) |
1340 { | |
8590 | 1341 #if !HAVE_MMX |
4176 | 1342 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
801 | 1343 int sum; |
1344 | |
1345 for(;size > 0;size--) { | |
1346 sum = -lum_m4[0]; | |
1347 sum += lum_m3[0] << 2; | |
1348 sum += lum_m2[0] << 1; | |
1349 lum_m4[0]=lum_m2[0]; | |
1350 sum += lum_m1[0] << 2; | |
1351 sum += -lum[0]; | |
1352 lum_m2[0] = cm[(sum + 4) >> 3]; | |
1353 lum_m4++; | |
1354 lum_m3++; | |
1355 lum_m2++; | |
1356 lum_m1++; | |
1357 lum++; | |
1358 } | |
1359 #else | |
1360 | |
1044 | 1361 { |
1362 pxor_r2r(mm7,mm7); | |
8316 | 1363 movq_m2r(ff_pw_4,mm6); |
1044 | 1364 } |
801 | 1365 for (;size > 3; size-=4) { |
1366 DEINT_INPLACE_LINE_LUM | |
1367 lum_m4+=4; | |
1368 lum_m3+=4; | |
1369 lum_m2+=4; | |
1370 lum_m1+=4; | |
1371 lum+=4; | |
1372 } | |
1373 #endif | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1374 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1375 |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1376 /* 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
|
1377 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
|
1378 against the top field. */ |
1064 | 1379 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
|
1380 const uint8_t *src1, int src_wrap, |
801 | 1381 int width, int height) |
1382 { | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1383 const uint8_t *src_m2, *src_m1, *src_0, *src_p1, *src_p2; |
801 | 1384 int y; |
1385 | |
1386 src_m2 = src1; | |
1387 src_m1 = src1; | |
1388 src_0=&src_m1[src_wrap]; | |
1389 src_p1=&src_0[src_wrap]; | |
1390 src_p2=&src_p1[src_wrap]; | |
1391 for(y=0;y<(height-2);y+=2) { | |
1392 memcpy(dst,src_m1,width); | |
1393 dst += dst_wrap; | |
1394 deinterlace_line(dst,src_m2,src_m1,src_0,src_p1,src_p2,width); | |
1395 src_m2 = src_0; | |
1396 src_m1 = src_p1; | |
1397 src_0 = src_p2; | |
1398 src_p1 += 2*src_wrap; | |
1399 src_p2 += 2*src_wrap; | |
1400 dst += dst_wrap; | |
1401 } | |
1402 memcpy(dst,src_m1,width); | |
1403 dst += dst_wrap; | |
1404 /* do last line */ | |
1405 deinterlace_line(dst,src_m2,src_m1,src_0,src_0,src_0,width); | |
1406 } | |
1407 | |
1064 | 1408 static void deinterlace_bottom_field_inplace(uint8_t *src1, int src_wrap, |
2979 | 1409 int width, int height) |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1410 { |
1064 | 1411 uint8_t *src_m1, *src_0, *src_p1, *src_p2; |
801 | 1412 int y; |
1064 | 1413 uint8_t *buf; |
1414 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
|
1415 |
801 | 1416 src_m1 = src1; |
1417 memcpy(buf,src_m1,width); | |
1418 src_0=&src_m1[src_wrap]; | |
1419 src_p1=&src_0[src_wrap]; | |
1420 src_p2=&src_p1[src_wrap]; | |
1421 for(y=0;y<(height-2);y+=2) { | |
1422 deinterlace_line_inplace(buf,src_m1,src_0,src_p1,src_p2,width); | |
1423 src_m1 = src_p1; | |
1424 src_0 = src_p2; | |
1425 src_p1 += 2*src_wrap; | |
1426 src_p2 += 2*src_wrap; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1427 } |
801 | 1428 /* do last line */ |
1429 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
|
1430 av_free(buf); |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1431 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1432 |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1433 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
|
1434 enum PixelFormat pix_fmt, int width, int height) |
0 | 1435 { |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1436 int i; |
0 | 1437 |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1438 if (pix_fmt != PIX_FMT_YUV420P && |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1439 pix_fmt != PIX_FMT_YUV422P && |
1425
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
1440 pix_fmt != PIX_FMT_YUV444P && |
5810 | 1441 pix_fmt != PIX_FMT_YUV411P && |
1442 pix_fmt != PIX_FMT_GRAY8) | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1443 return -1; |
801 | 1444 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
|
1445 return -1; |
801 | 1446 |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1447 for(i=0;i<3;i++) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1448 if (i == 1) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1449 switch(pix_fmt) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1450 case PIX_FMT_YUV420P: |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1451 width >>= 1; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1452 height >>= 1; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1453 break; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1454 case PIX_FMT_YUV422P: |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1455 width >>= 1; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1456 break; |
1425
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
1457 case PIX_FMT_YUV411P: |
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
1458 width >>= 2; |
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
1459 break; |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1460 default: |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1461 break; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1462 } |
5810 | 1463 if (pix_fmt == PIX_FMT_GRAY8) { |
1464 break; | |
1465 } | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1466 } |
801 | 1467 if (src == dst) { |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1468 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
|
1469 width, height); |
801 | 1470 } else { |
1471 deinterlace_bottom_field(dst->data[i],dst->linesize[i], | |
1472 src->data[i], src->linesize[i], | |
1473 width, height); | |
1474 } | |
0 | 1475 } |
5735 | 1476 emms_c(); |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1477 return 0; |
0 | 1478 } |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
1479 |