Mercurial > libavcodec.hg
annotate imgconvert.c @ 7983:47f50599b368 libavcodec
x264 has removed the b-rdo and bime options, and instead integrated
them into the subme number to attempt to reduce the number of
unnecessary options. subme now scales up to 9.
Patch by Jason Garett-Glaser %darkshikari A gmail P com%
author | gpoirier |
---|---|
date | Thu, 02 Oct 2008 19:05:35 +0000 |
parents | 573f52f011c0 |
children | 915bc657348f |
rev | line source |
---|---|
0 | 1 /* |
5355 | 2 * Misc image conversion routines |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
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 /** | |
1108 | 23 * @file imgconvert.c |
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" |
5354 | 35 #include "colorspace.h" |
0 | 36 |
801 | 37 #ifdef HAVE_MMX |
38 #include "i386/mmx.h" | |
39 #endif | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
40 |
1204 | 41 #define xglue(x, y) x ## y |
42 #define glue(x, y) xglue(x, y) | |
43 | |
4549 | 44 #define FF_COLOR_RGB 0 /**< RGB color space */ |
45 #define FF_COLOR_GRAY 1 /**< gray color space */ | |
46 #define FF_COLOR_YUV 2 /**< YUV color space. 16 <= Y <= 235, 16 <= U, V <= 240 */ | |
47 #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
|
48 |
4549 | 49 #define FF_PIXEL_PLANAR 0 /**< each channel has one component in AVPicture */ |
50 #define FF_PIXEL_PACKED 1 /**< only one components containing all the channels */ | |
51 #define FF_PIXEL_PALETTE 2 /**< one components containing indexes for a palette */ | |
1204 | 52 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
53 typedef struct PixFmtInfo { |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
54 const char *name; |
4549 | 55 uint8_t nb_channels; /**< number of channels (including alpha) */ |
56 uint8_t color_type; /**< color type (see FF_COLOR_xxx constants) */ | |
57 uint8_t pixel_type; /**< pixel storage type (see FF_PIXEL_xxx constants) */ | |
58 uint8_t is_alpha : 1; /**< true if alpha can be specified */ | |
59 uint8_t x_chroma_shift; /**< X chroma subsampling factor is 2 ^ shift */ | |
60 uint8_t y_chroma_shift; /**< Y chroma subsampling factor is 2 ^ shift */ | |
61 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
|
62 } PixFmtInfo; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
63 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
64 /* this table gives more information about formats */ |
3420 | 65 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
|
66 /* YUV formats */ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
67 [PIX_FMT_YUV420P] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
68 .name = "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, |
2967 | 73 .x_chroma_shift = 1, .y_chroma_shift = 1, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
74 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
75 [PIX_FMT_YUV422P] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
76 .name = "yuv422p", |
1204 | 77 .nb_channels = 3, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
78 .color_type = FF_COLOR_YUV, |
1204 | 79 .pixel_type = FF_PIXEL_PLANAR, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
80 .depth = 8, |
2967 | 81 .x_chroma_shift = 1, .y_chroma_shift = 0, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
82 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
83 [PIX_FMT_YUV444P] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
84 .name = "yuv444p", |
1204 | 85 .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
|
86 .color_type = FF_COLOR_YUV, |
1204 | 87 .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
|
88 .depth = 8, |
2967 | 89 .x_chroma_shift = 0, .y_chroma_shift = 0, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
90 }, |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
91 [PIX_FMT_YUYV422] = { |
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
92 .name = "yuyv422", |
1204 | 93 .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
|
94 .color_type = FF_COLOR_YUV, |
1204 | 95 .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
|
96 .depth = 8, |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
97 .x_chroma_shift = 1, .y_chroma_shift = 0, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
98 }, |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
99 [PIX_FMT_UYVY422] = { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
100 .name = "uyvy422", |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
101 .nb_channels = 1, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
102 .color_type = FF_COLOR_YUV, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
103 .pixel_type = FF_PIXEL_PACKED, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
104 .depth = 8, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
105 .x_chroma_shift = 1, .y_chroma_shift = 0, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
106 }, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
107 [PIX_FMT_YUV410P] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
108 .name = "yuv410p", |
1204 | 109 .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
|
110 .color_type = FF_COLOR_YUV, |
1204 | 111 .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
|
112 .depth = 8, |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
113 .x_chroma_shift = 2, .y_chroma_shift = 2, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
114 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
115 [PIX_FMT_YUV411P] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
116 .name = "yuv411p", |
1204 | 117 .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
|
118 .color_type = FF_COLOR_YUV, |
1204 | 119 .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
|
120 .depth = 8, |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
121 .x_chroma_shift = 2, .y_chroma_shift = 0, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
122 }, |
5363 | 123 [PIX_FMT_YUV440P] = { |
124 .name = "yuv440p", | |
125 .nb_channels = 3, | |
126 .color_type = FF_COLOR_YUV, | |
127 .pixel_type = FF_PIXEL_PLANAR, | |
128 .depth = 8, | |
129 .x_chroma_shift = 0, .y_chroma_shift = 1, | |
130 }, | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
131 |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
132 /* YUV formats with alpha plane */ |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
133 [PIX_FMT_YUVA420P] = { |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
134 .name = "yuva420p", |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
135 .nb_channels = 4, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
136 .color_type = FF_COLOR_YUV, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
137 .pixel_type = FF_PIXEL_PLANAR, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
138 .depth = 8, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
139 .x_chroma_shift = 1, .y_chroma_shift = 1, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
140 }, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
141 |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
142 /* JPEG YUV */ |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
143 [PIX_FMT_YUVJ420P] = { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
144 .name = "yuvj420p", |
1204 | 145 .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
|
146 .color_type = FF_COLOR_YUV_JPEG, |
1204 | 147 .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
|
148 .depth = 8, |
2967 | 149 .x_chroma_shift = 1, .y_chroma_shift = 1, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
150 }, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
151 [PIX_FMT_YUVJ422P] = { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
152 .name = "yuvj422p", |
1204 | 153 .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
|
154 .color_type = FF_COLOR_YUV_JPEG, |
1204 | 155 .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
|
156 .depth = 8, |
2967 | 157 .x_chroma_shift = 1, .y_chroma_shift = 0, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
158 }, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
159 [PIX_FMT_YUVJ444P] = { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
160 .name = "yuvj444p", |
1204 | 161 .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
|
162 .color_type = FF_COLOR_YUV_JPEG, |
1204 | 163 .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
|
164 .depth = 8, |
2967 | 165 .x_chroma_shift = 0, .y_chroma_shift = 0, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
166 }, |
5363 | 167 [PIX_FMT_YUVJ440P] = { |
168 .name = "yuvj440p", | |
169 .nb_channels = 3, | |
170 .color_type = FF_COLOR_YUV_JPEG, | |
171 .pixel_type = FF_PIXEL_PLANAR, | |
172 .depth = 8, | |
173 .x_chroma_shift = 0, .y_chroma_shift = 1, | |
174 }, | |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
175 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
176 /* RGB formats */ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
177 [PIX_FMT_RGB24] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
178 .name = "rgb24", |
1204 | 179 .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
|
180 .color_type = FF_COLOR_RGB, |
1204 | 181 .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
|
182 .depth = 8, |
1593 | 183 .x_chroma_shift = 0, .y_chroma_shift = 0, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
184 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
185 [PIX_FMT_BGR24] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
186 .name = "bgr24", |
1204 | 187 .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
|
188 .color_type = FF_COLOR_RGB, |
1204 | 189 .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
|
190 .depth = 8, |
1593 | 191 .x_chroma_shift = 0, .y_chroma_shift = 0, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
192 }, |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
193 [PIX_FMT_RGB32] = { |
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
194 .name = "rgb32", |
1204 | 195 .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
|
196 .color_type = FF_COLOR_RGB, |
1204 | 197 .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
|
198 .depth = 8, |
1593 | 199 .x_chroma_shift = 0, .y_chroma_shift = 0, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
200 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
201 [PIX_FMT_RGB565] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
202 .name = "rgb565", |
1204 | 203 .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
|
204 .color_type = FF_COLOR_RGB, |
1204 | 205 .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
|
206 .depth = 5, |
1593 | 207 .x_chroma_shift = 0, .y_chroma_shift = 0, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
208 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
209 [PIX_FMT_RGB555] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
210 .name = "rgb555", |
4208 | 211 .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
|
212 .color_type = FF_COLOR_RGB, |
1204 | 213 .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
|
214 .depth = 5, |
1593 | 215 .x_chroma_shift = 0, .y_chroma_shift = 0, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
216 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
217 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
218 /* gray / mono formats */ |
4066 | 219 [PIX_FMT_GRAY16BE] = { |
220 .name = "gray16be", | |
221 .nb_channels = 1, | |
222 .color_type = FF_COLOR_GRAY, | |
223 .pixel_type = FF_PIXEL_PLANAR, | |
224 .depth = 16, | |
225 }, | |
226 [PIX_FMT_GRAY16LE] = { | |
227 .name = "gray16le", | |
228 .nb_channels = 1, | |
229 .color_type = FF_COLOR_GRAY, | |
230 .pixel_type = FF_PIXEL_PLANAR, | |
231 .depth = 16, | |
232 }, | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
233 [PIX_FMT_GRAY8] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
234 .name = "gray", |
1204 | 235 .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
|
236 .color_type = FF_COLOR_GRAY, |
1204 | 237 .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
|
238 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
239 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
240 [PIX_FMT_MONOWHITE] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
241 .name = "monow", |
1204 | 242 .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
|
243 .color_type = FF_COLOR_GRAY, |
1204 | 244 .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
|
245 .depth = 1, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
246 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
247 [PIX_FMT_MONOBLACK] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
248 .name = "monob", |
1204 | 249 .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
|
250 .color_type = FF_COLOR_GRAY, |
1204 | 251 .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
|
252 .depth = 1, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
253 }, |
1055 | 254 |
255 /* paletted formats */ | |
256 [PIX_FMT_PAL8] = { | |
257 .name = "pal8", | |
1204 | 258 .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
|
259 .color_type = FF_COLOR_RGB, |
1204 | 260 .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
|
261 .depth = 8, |
1055 | 262 }, |
2179
34eaf41657d5
enrtries for PIX_FMT_XVMC_MPEG2_MC and PIX_FMT_XVMC_MPEG2_IDCT patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
2137
diff
changeset
|
263 [PIX_FMT_XVMC_MPEG2_MC] = { |
34eaf41657d5
enrtries for PIX_FMT_XVMC_MPEG2_MC and PIX_FMT_XVMC_MPEG2_IDCT patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
2137
diff
changeset
|
264 .name = "xvmcmc", |
34eaf41657d5
enrtries for PIX_FMT_XVMC_MPEG2_MC and PIX_FMT_XVMC_MPEG2_IDCT patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
2137
diff
changeset
|
265 }, |
34eaf41657d5
enrtries for PIX_FMT_XVMC_MPEG2_MC and PIX_FMT_XVMC_MPEG2_IDCT patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
2137
diff
changeset
|
266 [PIX_FMT_XVMC_MPEG2_IDCT] = { |
34eaf41657d5
enrtries for PIX_FMT_XVMC_MPEG2_MC and PIX_FMT_XVMC_MPEG2_IDCT patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
2137
diff
changeset
|
267 .name = "xvmcidct", |
34eaf41657d5
enrtries for PIX_FMT_XVMC_MPEG2_MC and PIX_FMT_XVMC_MPEG2_IDCT patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
2137
diff
changeset
|
268 }, |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
269 [PIX_FMT_UYYVYY411] = { |
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
270 .name = "uyyvyy411", |
2309 | 271 .nb_channels = 1, |
272 .color_type = FF_COLOR_YUV, | |
273 .pixel_type = FF_PIXEL_PACKED, | |
274 .depth = 8, | |
275 .x_chroma_shift = 2, .y_chroma_shift = 0, | |
276 }, | |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
277 [PIX_FMT_BGR32] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
278 .name = "bgr32", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
279 .nb_channels = 4, .is_alpha = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
280 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
281 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
282 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
283 .x_chroma_shift = 0, .y_chroma_shift = 0, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
284 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
285 [PIX_FMT_BGR565] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
286 .name = "bgr565", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
287 .nb_channels = 3, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
288 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
289 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
290 .depth = 5, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
291 .x_chroma_shift = 0, .y_chroma_shift = 0, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
292 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
293 [PIX_FMT_BGR555] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
294 .name = "bgr555", |
4207
bc9de4875ebd
BGR555 has never been working as alpha supporting format. Remove the false setting.
alex
parents:
4201
diff
changeset
|
295 .nb_channels = 3, |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
296 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
297 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
298 .depth = 5, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
299 .x_chroma_shift = 0, .y_chroma_shift = 0, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
300 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
301 [PIX_FMT_RGB8] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
302 .name = "rgb8", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
303 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
304 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
305 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
306 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
307 .x_chroma_shift = 0, .y_chroma_shift = 0, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
308 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
309 [PIX_FMT_RGB4] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
310 .name = "rgb4", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
311 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
312 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
313 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
314 .depth = 4, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
315 .x_chroma_shift = 0, .y_chroma_shift = 0, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
316 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
317 [PIX_FMT_RGB4_BYTE] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
318 .name = "rgb4_byte", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
319 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
320 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
321 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
322 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
323 .x_chroma_shift = 0, .y_chroma_shift = 0, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
324 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
325 [PIX_FMT_BGR8] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
326 .name = "bgr8", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
327 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
328 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
329 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
330 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
331 .x_chroma_shift = 0, .y_chroma_shift = 0, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
332 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
333 [PIX_FMT_BGR4] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
334 .name = "bgr4", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
335 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
336 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
337 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
338 .depth = 4, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
339 .x_chroma_shift = 0, .y_chroma_shift = 0, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
340 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
341 [PIX_FMT_BGR4_BYTE] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
342 .name = "bgr4_byte", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
343 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
344 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
345 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
346 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
347 .x_chroma_shift = 0, .y_chroma_shift = 0, |
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_NV12] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
350 .name = "nv12", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
351 .nb_channels = 2, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
352 .color_type = FF_COLOR_YUV, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
353 .pixel_type = FF_PIXEL_PLANAR, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
354 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
355 .x_chroma_shift = 1, .y_chroma_shift = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
356 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
357 [PIX_FMT_NV21] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
358 .name = "nv12", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
359 .nb_channels = 2, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
360 .color_type = FF_COLOR_YUV, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
361 .pixel_type = FF_PIXEL_PLANAR, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
362 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
363 .x_chroma_shift = 1, .y_chroma_shift = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
364 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
365 |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
366 [PIX_FMT_BGR32_1] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
367 .name = "bgr32_1", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
368 .nb_channels = 4, .is_alpha = 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 = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
372 .x_chroma_shift = 0, .y_chroma_shift = 0, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
373 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
374 [PIX_FMT_RGB32_1] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
375 .name = "rgb32_1", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
376 .nb_channels = 4, .is_alpha = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
377 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
378 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
379 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
380 .x_chroma_shift = 0, .y_chroma_shift = 0, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
381 }, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
382 }; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
383 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
384 void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift) |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
385 { |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
386 *h_shift = pix_fmt_info[pix_fmt].x_chroma_shift; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
387 *v_shift = pix_fmt_info[pix_fmt].y_chroma_shift; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
388 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
389 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
390 const char *avcodec_get_pix_fmt_name(int pix_fmt) |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
391 { |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
392 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
|
393 return NULL; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
394 else |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
395 return pix_fmt_info[pix_fmt].name; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
396 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
397 |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
398 enum PixelFormat avcodec_get_pix_fmt(const char* name) |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
399 { |
2967 | 400 int i; |
401 | |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
402 for (i=0; i < PIX_FMT_NB; i++) |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
403 if (!strcmp(pix_fmt_info[i].name, name)) |
7463
5515e19b9137
Add graceful error handling to avcodec_get_pix_fmt_name() and avcodec_get_pix_fmt().
pross
parents:
6963
diff
changeset
|
404 return i; |
5515e19b9137
Add graceful error handling to avcodec_get_pix_fmt_name() and avcodec_get_pix_fmt().
pross
parents:
6963
diff
changeset
|
405 return PIX_FMT_NONE; |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
406 } |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
407 |
5084
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
408 void avcodec_pix_fmt_string (char *buf, int buf_size, int pix_fmt) |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
409 { |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
410 /* print header */ |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
411 if (pix_fmt < 0) |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
412 snprintf (buf, buf_size, |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
413 "name " " nb_channels" " depth" " is_alpha" |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
414 ); |
6911 | 415 else{ |
416 PixFmtInfo info= pix_fmt_info[pix_fmt]; | |
417 | |
418 char is_alpha_char= info.is_alpha ? 'y' : 'n'; | |
419 | |
5084
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
420 snprintf (buf, buf_size, |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
421 "%-10s" " %1d " " %2d " " %c ", |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
422 info.name, |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
423 info.nb_channels, |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
424 info.depth, |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
425 is_alpha_char |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
426 ); |
6911 | 427 } |
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 |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
430 int ff_fill_linesize(AVPicture *picture, int 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
|
431 { |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
432 int w2; |
3420 | 433 const PixFmtInfo *pinfo; |
2967 | 434 |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
435 memset(picture->linesize, 0, sizeof(picture->linesize)); |
2422 | 436 |
1047
3f316a471019
handle odd image sizes when using subsampled chroma (useful for JPEG images)
bellard
parents:
1044
diff
changeset
|
437 pinfo = &pix_fmt_info[pix_fmt]; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
438 switch(pix_fmt) { |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
439 case PIX_FMT_YUV420P: |
1047
3f316a471019
handle odd image sizes when using subsampled chroma (useful for JPEG images)
bellard
parents:
1044
diff
changeset
|
440 case PIX_FMT_YUV422P: |
3f316a471019
handle odd image sizes when using subsampled chroma (useful for JPEG images)
bellard
parents:
1044
diff
changeset
|
441 case PIX_FMT_YUV444P: |
3f316a471019
handle odd image sizes when using subsampled chroma (useful for JPEG images)
bellard
parents:
1044
diff
changeset
|
442 case PIX_FMT_YUV410P: |
3f316a471019
handle odd image sizes when using subsampled chroma (useful for JPEG images)
bellard
parents:
1044
diff
changeset
|
443 case PIX_FMT_YUV411P: |
5363 | 444 case PIX_FMT_YUV440P: |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
445 case PIX_FMT_YUVJ420P: |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
446 case PIX_FMT_YUVJ422P: |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
447 case PIX_FMT_YUVJ444P: |
5363 | 448 case PIX_FMT_YUVJ440P: |
1047
3f316a471019
handle odd image sizes when using subsampled chroma (useful for JPEG images)
bellard
parents:
1044
diff
changeset
|
449 w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
450 picture->linesize[0] = width; |
1047
3f316a471019
handle odd image sizes when using subsampled chroma (useful for JPEG images)
bellard
parents:
1044
diff
changeset
|
451 picture->linesize[1] = w2; |
3f316a471019
handle odd image sizes when using subsampled chroma (useful for JPEG images)
bellard
parents:
1044
diff
changeset
|
452 picture->linesize[2] = w2; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
453 break; |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
454 case PIX_FMT_YUVA420P: |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
455 w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift; |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
456 picture->linesize[0] = width; |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
457 picture->linesize[1] = w2; |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
458 picture->linesize[2] = w2; |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
459 picture->linesize[3] = width; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
460 break; |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
461 case PIX_FMT_NV12: |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
462 case PIX_FMT_NV21: |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
463 w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift; |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
464 picture->linesize[0] = width; |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
465 picture->linesize[1] = w2; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
466 break; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
467 case PIX_FMT_RGB24: |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
468 case PIX_FMT_BGR24: |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
469 picture->linesize[0] = width * 3; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
470 break; |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
471 case PIX_FMT_RGB32: |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
472 case PIX_FMT_BGR32: |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
473 case PIX_FMT_RGB32_1: |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
474 case PIX_FMT_BGR32_1: |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
475 picture->linesize[0] = width * 4; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
476 break; |
4066 | 477 case PIX_FMT_GRAY16BE: |
478 case PIX_FMT_GRAY16LE: | |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
479 case PIX_FMT_BGR555: |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
480 case PIX_FMT_BGR565: |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
481 case PIX_FMT_RGB555: |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
482 case PIX_FMT_RGB565: |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
483 case PIX_FMT_YUYV422: |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
484 picture->linesize[0] = width * 2; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
485 break; |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
486 case PIX_FMT_UYVY422: |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
487 picture->linesize[0] = width * 2; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
488 break; |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
489 case PIX_FMT_UYYVYY411: |
2309 | 490 picture->linesize[0] = width + width/2; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
491 break; |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
492 case PIX_FMT_RGB8: |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
493 case PIX_FMT_BGR8: |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
494 case PIX_FMT_RGB4_BYTE: |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
495 case PIX_FMT_BGR4_BYTE: |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
496 case PIX_FMT_GRAY8: |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
497 picture->linesize[0] = width; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
498 break; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
499 case PIX_FMT_RGB4: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
500 case PIX_FMT_BGR4: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
501 picture->linesize[0] = width / 2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
502 break; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
503 case PIX_FMT_MONOWHITE: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
504 case PIX_FMT_MONOBLACK: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
505 picture->linesize[0] = (width + 7) >> 3; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
506 break; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
507 case PIX_FMT_PAL8: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
508 picture->linesize[0] = width; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
509 picture->linesize[1] = 4; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
510 break; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
511 default: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
512 return -1; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
513 } |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
514 return 0; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
515 } |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
516 |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
517 int ff_fill_pointer(AVPicture *picture, uint8_t *ptr, int pix_fmt, |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
518 int height) |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
519 { |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
520 int size, h2, size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
521 const PixFmtInfo *pinfo; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
522 |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
523 pinfo = &pix_fmt_info[pix_fmt]; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
524 size = picture->linesize[0] * height; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
525 switch(pix_fmt) { |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
526 case PIX_FMT_YUV420P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
527 case PIX_FMT_YUV422P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
528 case PIX_FMT_YUV444P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
529 case PIX_FMT_YUV410P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
530 case PIX_FMT_YUV411P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
531 case PIX_FMT_YUV440P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
532 case PIX_FMT_YUVJ420P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
533 case PIX_FMT_YUVJ422P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
534 case PIX_FMT_YUVJ444P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
535 case PIX_FMT_YUVJ440P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
536 h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
537 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
|
538 picture->data[0] = ptr; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
539 picture->data[1] = picture->data[0] + size; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
540 picture->data[2] = picture->data[1] + size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
541 picture->data[3] = NULL; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
542 return size + 2 * size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
543 case PIX_FMT_YUVA420P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
544 h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
545 size2 = picture->linesize[1] * h2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
546 picture->data[0] = ptr; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
547 picture->data[1] = picture->data[0] + size; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
548 picture->data[2] = picture->data[1] + size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
549 picture->data[3] = picture->data[1] + size2 + size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
550 return 2 * size + 2 * size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
551 case PIX_FMT_NV12: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
552 case PIX_FMT_NV21: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
553 h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
554 size2 = picture->linesize[1] * h2 * 2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
555 picture->data[0] = ptr; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
556 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
|
557 picture->data[2] = NULL; |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
558 picture->data[3] = NULL; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
559 return size + 2 * size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
560 case PIX_FMT_RGB24: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
561 case PIX_FMT_BGR24: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
562 case PIX_FMT_RGB32: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
563 case PIX_FMT_BGR32: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
564 case PIX_FMT_RGB32_1: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
565 case PIX_FMT_BGR32_1: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
566 case PIX_FMT_GRAY16BE: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
567 case PIX_FMT_GRAY16LE: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
568 case PIX_FMT_BGR555: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
569 case PIX_FMT_BGR565: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
570 case PIX_FMT_RGB555: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
571 case PIX_FMT_RGB565: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
572 case PIX_FMT_YUYV422: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
573 case PIX_FMT_UYVY422: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
574 case PIX_FMT_UYYVYY411: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
575 case PIX_FMT_RGB8: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
576 case PIX_FMT_BGR8: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
577 case PIX_FMT_RGB4_BYTE: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
578 case PIX_FMT_BGR4_BYTE: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
579 case PIX_FMT_GRAY8: |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
580 case PIX_FMT_RGB4: |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
581 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
|
582 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
|
583 case PIX_FMT_MONOBLACK: |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
584 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
|
585 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
|
586 picture->data[2] = NULL; |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
587 picture->data[3] = NULL; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
588 return size; |
1055 | 589 case PIX_FMT_PAL8: |
590 size2 = (size + 3) & ~3; | |
591 picture->data[0] = ptr; | |
592 picture->data[1] = ptr + size2; /* palette is stored here as 256 32 bit words */ | |
593 picture->data[2] = NULL; | |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
594 picture->data[3] = NULL; |
1055 | 595 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
|
596 default: |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
597 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
|
598 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
|
599 picture->data[2] = NULL; |
1055 | 600 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
|
601 return -1; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
602 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
603 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
604 |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
605 int avpicture_fill(AVPicture *picture, uint8_t *ptr, |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
606 int pix_fmt, int width, int height) |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
607 { |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
608 |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
609 if(avcodec_check_dimensions(NULL, width, height)) |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
610 return -1; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
611 |
6357 | 612 if (ff_fill_linesize(picture, pix_fmt, width)) |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
613 return -1; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
614 |
6357 | 615 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
|
616 } |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
617 |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
618 int avpicture_layout(const AVPicture* src, int pix_fmt, int width, int height, |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
619 unsigned char *dest, int dest_size) |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
620 { |
3420 | 621 const PixFmtInfo* pf = &pix_fmt_info[pix_fmt]; |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
622 int i, j, w, h, data_planes; |
2967 | 623 const unsigned char* s; |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
624 int size = avpicture_get_size(pix_fmt, width, height); |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
625 |
2422 | 626 if (size > dest_size || size < 0) |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
627 return -1; |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
628 |
1243
5d2376294fbf
* fixing a bug in avpicture_layout (PAL8 wasn't handled properly)
romansh
parents:
1231
diff
changeset
|
629 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
|
630 if (pix_fmt == PIX_FMT_YUYV422 || |
2967 | 631 pix_fmt == PIX_FMT_UYVY422 || |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
632 pix_fmt == PIX_FMT_BGR565 || |
4088 | 633 pix_fmt == PIX_FMT_BGR555 || |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
634 pix_fmt == PIX_FMT_RGB565 || |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
635 pix_fmt == PIX_FMT_RGB555) |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
636 w = width * 2; |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
637 else if (pix_fmt == PIX_FMT_UYYVYY411) |
2979 | 638 w = width + width/2; |
639 else if (pix_fmt == PIX_FMT_PAL8) | |
640 w = width; | |
641 else | |
642 w = width * (pf->depth * pf->nb_channels / 8); | |
2967 | 643 |
2979 | 644 data_planes = 1; |
645 h = height; | |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
646 } else { |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
647 data_planes = pf->nb_channels; |
2979 | 648 w = (width*pf->depth + 7)/8; |
649 h = height; | |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
650 } |
2967 | 651 |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
652 for (i=0; i<data_planes; i++) { |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
653 if (i == 1) { |
2979 | 654 w = width >> pf->x_chroma_shift; |
655 h = height >> pf->y_chroma_shift; | |
656 } | |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
657 s = src->data[i]; |
2979 | 658 for(j=0; j<h; j++) { |
659 memcpy(dest, s, w); | |
660 dest += w; | |
661 s += src->linesize[i]; | |
662 } | |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
663 } |
2967 | 664 |
1243
5d2376294fbf
* fixing a bug in avpicture_layout (PAL8 wasn't handled properly)
romansh
parents:
1231
diff
changeset
|
665 if (pf->pixel_type == FF_PIXEL_PALETTE) |
2979 | 666 memcpy((unsigned char *)(((size_t)dest + 3) & ~3), src->data[1], 256 * 4); |
2967 | 667 |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
668 return size; |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
669 } |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
670 |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
671 int avpicture_get_size(int pix_fmt, int width, int height) |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
672 { |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
673 AVPicture dummy_pict; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
674 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
|
675 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
676 |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
677 int avcodec_get_pix_fmt_loss(int dst_pix_fmt, int 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
|
678 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
|
679 { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
680 const PixFmtInfo *pf, *ps; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
681 int loss; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
682 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
683 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
|
684 pf = &pix_fmt_info[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
|
685 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
686 /* compute loss */ |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
687 loss = 0; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
688 pf = &pix_fmt_info[dst_pix_fmt]; |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
689 if (pf->depth < ps->depth || |
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
690 (dst_pix_fmt == PIX_FMT_RGB555 && src_pix_fmt == PIX_FMT_RGB565)) |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
691 loss |= FF_LOSS_DEPTH; |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
692 if (pf->x_chroma_shift > ps->x_chroma_shift || |
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
693 pf->y_chroma_shift > ps->y_chroma_shift) |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
694 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
|
695 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
|
696 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
|
697 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
|
698 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
|
699 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
|
700 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
701 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
|
702 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
|
703 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
|
704 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
705 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
|
706 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
|
707 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
|
708 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
709 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
|
710 if (ps->color_type != FF_COLOR_YUV_JPEG && |
2967 | 711 ps->color_type != FF_COLOR_YUV && |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
712 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
|
713 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
|
714 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
715 default: |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
716 /* 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
|
717 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
|
718 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
|
719 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
720 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
721 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
|
722 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
|
723 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
|
724 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
|
725 loss |= FF_LOSS_ALPHA; |
2967 | 726 if (pf->pixel_type == FF_PIXEL_PALETTE && |
1204 | 727 (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
|
728 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
|
729 return loss; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
730 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
731 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
732 static int avg_bits_per_pixel(int pix_fmt) |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
733 { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
734 int bits; |
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; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
736 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
737 pf = &pix_fmt_info[pix_fmt]; |
1204 | 738 switch(pf->pixel_type) { |
739 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
|
740 switch(pix_fmt) { |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
741 case PIX_FMT_YUYV422: |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
742 case PIX_FMT_UYVY422: |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
743 case PIX_FMT_RGB565: |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
744 case PIX_FMT_RGB555: |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
745 case PIX_FMT_BGR565: |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
746 case PIX_FMT_BGR555: |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
747 bits = 16; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
748 break; |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
749 case PIX_FMT_UYYVYY411: |
2979 | 750 bits = 12; |
751 break; | |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
752 default: |
1204 | 753 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
|
754 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
755 } |
1204 | 756 break; |
757 case FF_PIXEL_PLANAR: | |
758 if (pf->x_chroma_shift == 0 && pf->y_chroma_shift == 0) { | |
759 bits = pf->depth * pf->nb_channels; | |
760 } else { | |
2967 | 761 bits = pf->depth + ((2 * pf->depth) >> |
1204 | 762 (pf->x_chroma_shift + pf->y_chroma_shift)); |
763 } | |
764 break; | |
765 case FF_PIXEL_PALETTE: | |
766 bits = 8; | |
767 break; | |
768 default: | |
769 bits = -1; | |
770 break; | |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
771 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
772 return bits; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
773 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
774 |
7832
573f52f011c0
avcodec_find_best_pix_fmt() needs a 64bit mask as there are more than 32 pix_fmts.
michael
parents:
7824
diff
changeset
|
775 static int avcodec_find_best_pix_fmt1(int64_t pix_fmt_mask, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
776 int 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
|
777 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
|
778 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
|
779 { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
780 int dist, i, loss, min_dist, 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
|
781 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
782 /* find exact color match with smallest size */ |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
783 dst_pix_fmt = -1; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
784 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
|
785 for(i = 0;i < PIX_FMT_NB; i++) { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
786 if (pix_fmt_mask & (1 << i)) { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
787 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
|
788 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
|
789 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
|
790 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
|
791 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
|
792 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
|
793 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
794 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
795 } |
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 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
|
798 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
799 |
7832
573f52f011c0
avcodec_find_best_pix_fmt() needs a 64bit mask as there are more than 32 pix_fmts.
michael
parents:
7824
diff
changeset
|
800 int avcodec_find_best_pix_fmt(int64_t pix_fmt_mask, int 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
|
801 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
|
802 { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
803 int dst_pix_fmt, loss_mask, i; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
804 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
|
805 ~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
|
806 ~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
|
807 ~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
|
808 ~(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
|
809 ~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
|
810 ~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
|
811 0, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
812 }; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
813 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
814 /* 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
|
815 i = 0; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
816 for(;;) { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
817 loss_mask = loss_mask_order[i++]; |
2967 | 818 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
|
819 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
|
820 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
|
821 goto found; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
822 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
|
823 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
824 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
825 return -1; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
826 found: |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
827 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
|
828 *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
|
829 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
|
830 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
831 |
3245 | 832 void ff_img_copy_plane(uint8_t *dst, int dst_wrap, |
1205 | 833 const uint8_t *src, int src_wrap, |
834 int width, int height) | |
1204 | 835 { |
2967 | 836 if((!dst) || (!src)) |
2785 | 837 return; |
1204 | 838 for(;height > 0; height--) { |
839 memcpy(dst, src, width); | |
840 dst += dst_wrap; | |
841 src += src_wrap; | |
842 } | |
843 } | |
844 | |
6358 | 845 int ff_get_plane_bytewidth(enum PixelFormat pix_fmt, int width, int plane) |
1204 | 846 { |
6347 | 847 int bits; |
3420 | 848 const PixFmtInfo *pf = &pix_fmt_info[pix_fmt]; |
2967 | 849 |
1204 | 850 pf = &pix_fmt_info[pix_fmt]; |
851 switch(pf->pixel_type) { | |
852 case FF_PIXEL_PACKED: | |
853 switch(pix_fmt) { | |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
854 case PIX_FMT_YUYV422: |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
855 case PIX_FMT_UYVY422: |
1204 | 856 case PIX_FMT_RGB565: |
857 case PIX_FMT_RGB555: | |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
858 case PIX_FMT_BGR565: |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
859 case PIX_FMT_BGR555: |
1204 | 860 bits = 16; |
861 break; | |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
862 case PIX_FMT_UYYVYY411: |
2979 | 863 bits = 12; |
864 break; | |
1204 | 865 default: |
866 bits = pf->depth * pf->nb_channels; | |
867 break; | |
868 } | |
6347 | 869 return (width * bits + 7) >> 3; |
870 break; | |
871 case FF_PIXEL_PLANAR: | |
872 if (plane == 1 || plane == 2) | |
873 width >>= pf->x_chroma_shift; | |
874 | |
875 return (width * pf->depth + 7) >> 3; | |
876 break; | |
877 case FF_PIXEL_PALETTE: | |
878 if (plane == 0) | |
879 return width; | |
1204 | 880 break; |
6347 | 881 } |
882 | |
883 return -1; | |
884 } | |
885 | |
886 void av_picture_copy(AVPicture *dst, const AVPicture *src, | |
887 int pix_fmt, int width, int height) | |
888 { | |
889 int i; | |
890 const PixFmtInfo *pf = &pix_fmt_info[pix_fmt]; | |
891 | |
892 pf = &pix_fmt_info[pix_fmt]; | |
893 switch(pf->pixel_type) { | |
894 case FF_PIXEL_PACKED: | |
1204 | 895 case FF_PIXEL_PLANAR: |
896 for(i = 0; i < pf->nb_channels; i++) { | |
897 int w, h; | |
6358 | 898 int bwidth = ff_get_plane_bytewidth(pix_fmt, width, i); |
1204 | 899 w = width; |
900 h = height; | |
901 if (i == 1 || i == 2) { | |
902 w >>= pf->x_chroma_shift; | |
903 h >>= pf->y_chroma_shift; | |
904 } | |
3245 | 905 ff_img_copy_plane(dst->data[i], dst->linesize[i], |
1204 | 906 src->data[i], src->linesize[i], |
907 bwidth, h); | |
908 } | |
909 break; | |
910 case FF_PIXEL_PALETTE: | |
3245 | 911 ff_img_copy_plane(dst->data[0], dst->linesize[0], |
1204 | 912 src->data[0], src->linesize[0], |
913 width, height); | |
914 /* copy the palette */ | |
3245 | 915 ff_img_copy_plane(dst->data[1], dst->linesize[1], |
1204 | 916 src->data[1], src->linesize[1], |
917 4, 256); | |
918 break; | |
919 } | |
920 } | |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
921 |
0 | 922 /* XXX: totally non optimized */ |
923 | |
4517 | 924 static void yuyv422_to_yuv420p(AVPicture *dst, const AVPicture *src, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
925 int width, int height) |
0 | 926 { |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
927 const uint8_t *p, *p1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
928 uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
929 int w; |
2967 | 930 |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
931 p1 = src->data[0]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
932 lum1 = dst->data[0]; |
1207 | 933 cb1 = dst->data[1]; |
934 cr1 = dst->data[2]; | |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
935 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
936 for(;height >= 1; height -= 2) { |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
937 p = p1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
938 lum = lum1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
939 cb = cb1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
940 cr = cr1; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
941 for(w = width; w >= 2; w -= 2) { |
1028
e76fb91de4cc
reversing my own stupidity ... (raw packed yuv422 files dont use YUY2 but UYVY)
michaelni
parents:
1023
diff
changeset
|
942 lum[0] = p[0]; |
e76fb91de4cc
reversing my own stupidity ... (raw packed yuv422 files dont use YUY2 but UYVY)
michaelni
parents:
1023
diff
changeset
|
943 cb[0] = p[1]; |
e76fb91de4cc
reversing my own stupidity ... (raw packed yuv422 files dont use YUY2 but UYVY)
michaelni
parents:
1023
diff
changeset
|
944 lum[1] = p[2]; |
e76fb91de4cc
reversing my own stupidity ... (raw packed yuv422 files dont use YUY2 but UYVY)
michaelni
parents:
1023
diff
changeset
|
945 cr[0] = p[3]; |
0 | 946 p += 4; |
947 lum += 2; | |
948 cb++; | |
949 cr++; | |
950 } | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
951 if (w) { |
1028
e76fb91de4cc
reversing my own stupidity ... (raw packed yuv422 files dont use YUY2 but UYVY)
michaelni
parents:
1023
diff
changeset
|
952 lum[0] = p[0]; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
953 cb[0] = p[1]; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
954 cr[0] = p[3]; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
955 cb++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
956 cr++; |
0 | 957 } |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
958 p1 += src->linesize[0]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
959 lum1 += dst->linesize[0]; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
960 if (height>1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
961 p = p1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
962 lum = lum1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
963 for(w = width; w >= 2; w -= 2) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
964 lum[0] = p[0]; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
965 lum[1] = p[2]; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
966 p += 4; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
967 lum += 2; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
968 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
969 if (w) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
970 lum[0] = p[0]; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
971 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
972 p1 += src->linesize[0]; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
973 lum1 += dst->linesize[0]; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1282
diff
changeset
|
974 } |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
975 cb1 += dst->linesize[1]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
976 cr1 += dst->linesize[2]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
977 } |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
978 } |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
979 |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
980 static void uyvy422_to_yuv420p(AVPicture *dst, const AVPicture *src, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
981 int width, int height) |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
982 { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
983 const uint8_t *p, *p1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
984 uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
985 int w; |
2967 | 986 |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
987 p1 = src->data[0]; |
2967 | 988 |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
989 lum1 = dst->data[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
990 cb1 = dst->data[1]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
991 cr1 = dst->data[2]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
992 |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
993 for(;height >= 1; height -= 2) { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
994 p = p1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
995 lum = lum1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
996 cb = cb1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
997 cr = cr1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
998 for(w = width; w >= 2; w -= 2) { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
999 lum[0] = p[1]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1000 cb[0] = p[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1001 lum[1] = p[3]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1002 cr[0] = p[2]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1003 p += 4; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1004 lum += 2; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1005 cb++; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1006 cr++; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1007 } |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1008 if (w) { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1009 lum[0] = p[1]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1010 cb[0] = p[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1011 cr[0] = p[2]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1012 cb++; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1013 cr++; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1014 } |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1015 p1 += src->linesize[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1016 lum1 += dst->linesize[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1017 if (height>1) { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1018 p = p1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1019 lum = lum1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1020 for(w = width; w >= 2; w -= 2) { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1021 lum[0] = p[1]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1022 lum[1] = p[3]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1023 p += 4; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1024 lum += 2; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1025 } |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1026 if (w) { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1027 lum[0] = p[1]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1028 } |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1029 p1 += src->linesize[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1030 lum1 += dst->linesize[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1031 } |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1032 cb1 += dst->linesize[1]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1033 cr1 += dst->linesize[2]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1034 } |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1035 } |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1036 |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1037 |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1038 static void uyvy422_to_yuv422p(AVPicture *dst, const AVPicture *src, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1039 int width, int height) |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1040 { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1041 const uint8_t *p, *p1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1042 uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1043 int w; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1044 |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1045 p1 = src->data[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1046 lum1 = dst->data[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1047 cb1 = dst->data[1]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1048 cr1 = dst->data[2]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1049 for(;height > 0; height--) { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1050 p = p1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1051 lum = lum1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1052 cb = cb1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1053 cr = cr1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1054 for(w = width; w >= 2; w -= 2) { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1055 lum[0] = p[1]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1056 cb[0] = p[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1057 lum[1] = p[3]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1058 cr[0] = p[2]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1059 p += 4; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1060 lum += 2; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1061 cb++; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1062 cr++; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1063 } |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1064 p1 += src->linesize[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1065 lum1 += dst->linesize[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1066 cb1 += dst->linesize[1]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1067 cr1 += dst->linesize[2]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1068 } |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1069 } |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1070 |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1071 |
4517 | 1072 static void yuyv422_to_yuv422p(AVPicture *dst, const AVPicture *src, |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1073 int width, int height) |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1074 { |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1075 const uint8_t *p, *p1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1076 uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1077 int w; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1078 |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1079 p1 = src->data[0]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1080 lum1 = dst->data[0]; |
1207 | 1081 cb1 = dst->data[1]; |
1082 cr1 = dst->data[2]; | |
1083 for(;height > 0; height--) { | |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1084 p = p1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1085 lum = lum1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1086 cb = cb1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1087 cr = cr1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1088 for(w = width; w >= 2; w -= 2) { |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1089 lum[0] = p[0]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1090 cb[0] = p[1]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1091 lum[1] = p[2]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1092 cr[0] = p[3]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1093 p += 4; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1094 lum += 2; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1095 cb++; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1096 cr++; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1097 } |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1098 p1 += src->linesize[0]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1099 lum1 += dst->linesize[0]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1100 cb1 += dst->linesize[1]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1101 cr1 += dst->linesize[2]; |
0 | 1102 } |
1103 } | |
1104 | |
4517 | 1105 static void yuv422p_to_yuyv422(AVPicture *dst, const AVPicture *src, |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1106 int width, int height) |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1107 { |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1108 uint8_t *p, *p1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1109 const uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1110 int w; |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1111 |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1112 p1 = dst->data[0]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1113 lum1 = src->data[0]; |
1207 | 1114 cb1 = src->data[1]; |
1115 cr1 = src->data[2]; | |
1116 for(;height > 0; height--) { | |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1117 p = p1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1118 lum = lum1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1119 cb = cb1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1120 cr = cr1; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1121 for(w = width; w >= 2; w -= 2) { |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1122 p[0] = lum[0]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1123 p[1] = cb[0]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1124 p[2] = lum[1]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1125 p[3] = cr[0]; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1126 p += 4; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1127 lum += 2; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1128 cb++; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1129 cr++; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1130 } |
1207 | 1131 p1 += dst->linesize[0]; |
1132 lum1 += src->linesize[0]; | |
1133 cb1 += src->linesize[1]; | |
1134 cr1 += src->linesize[2]; | |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1135 } |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1136 } |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1137 |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1138 static void yuv422p_to_uyvy422(AVPicture *dst, const AVPicture *src, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1139 int width, int height) |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1140 { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1141 uint8_t *p, *p1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1142 const uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1143 int w; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1144 |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1145 p1 = dst->data[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1146 lum1 = src->data[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1147 cb1 = src->data[1]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1148 cr1 = src->data[2]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1149 for(;height > 0; height--) { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1150 p = p1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1151 lum = lum1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1152 cb = cb1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1153 cr = cr1; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1154 for(w = width; w >= 2; w -= 2) { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1155 p[1] = lum[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1156 p[0] = cb[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1157 p[3] = lum[1]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1158 p[2] = cr[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1159 p += 4; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1160 lum += 2; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1161 cb++; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1162 cr++; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1163 } |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1164 p1 += dst->linesize[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1165 lum1 += src->linesize[0]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1166 cb1 += src->linesize[1]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1167 cr1 += src->linesize[2]; |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1168 } |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1169 } |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1170 |
4516 | 1171 static void uyyvyy411_to_yuv411p(AVPicture *dst, const AVPicture *src, |
2309 | 1172 int width, int height) |
1173 { | |
1174 const uint8_t *p, *p1; | |
1175 uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1; | |
1176 int w; | |
1177 | |
1178 p1 = src->data[0]; | |
1179 lum1 = dst->data[0]; | |
1180 cb1 = dst->data[1]; | |
1181 cr1 = dst->data[2]; | |
1182 for(;height > 0; height--) { | |
1183 p = p1; | |
1184 lum = lum1; | |
1185 cb = cb1; | |
1186 cr = cr1; | |
1187 for(w = width; w >= 4; w -= 4) { | |
1188 cb[0] = p[0]; | |
2979 | 1189 lum[0] = p[1]; |
2309 | 1190 lum[1] = p[2]; |
1191 cr[0] = p[3]; | |
2979 | 1192 lum[2] = p[4]; |
1193 lum[3] = p[5]; | |
2309 | 1194 p += 6; |
1195 lum += 4; | |
1196 cb++; | |
1197 cr++; | |
1198 } | |
1199 p1 += src->linesize[0]; | |
1200 lum1 += dst->linesize[0]; | |
1201 cb1 += dst->linesize[1]; | |
1202 cr1 += dst->linesize[2]; | |
1203 } | |
1204 } | |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1205 |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1206 |
4517 | 1207 static void yuv420p_to_yuyv422(AVPicture *dst, const AVPicture *src, |
2326
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1208 int width, int height) |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1209 { |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1210 int w, h; |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1211 uint8_t *line1, *line2, *linesrc = dst->data[0]; |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1212 uint8_t *lum1, *lum2, *lumsrc = src->data[0]; |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1213 uint8_t *cb1, *cb2 = src->data[1]; |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1214 uint8_t *cr1, *cr2 = src->data[2]; |
2967 | 1215 |
2326
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1216 for(h = height / 2; h--;) { |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1217 line1 = linesrc; |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1218 line2 = linesrc + dst->linesize[0]; |
2967 | 1219 |
2326
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1220 lum1 = lumsrc; |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1221 lum2 = lumsrc + src->linesize[0]; |
2967 | 1222 |
2326
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1223 cb1 = cb2; |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1224 cr1 = cr2; |
2967 | 1225 |
2326
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1226 for(w = width / 2; w--;) { |
2967 | 1227 *line1++ = *lum1++; *line2++ = *lum2++; |
1228 *line1++ = *line2++ = *cb1++; | |
1229 *line1++ = *lum1++; *line2++ = *lum2++; | |
2326
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1230 *line1++ = *line2++ = *cr1++; |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1231 } |
2967 | 1232 |
2326
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1233 linesrc += dst->linesize[0] * 2; |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1234 lumsrc += src->linesize[0] * 2; |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1235 cb2 += src->linesize[1]; |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1236 cr2 += src->linesize[2]; |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1237 } |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1238 } |
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1239 |
2366
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1240 static void yuv420p_to_uyvy422(AVPicture *dst, const AVPicture *src, |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1241 int width, int height) |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1242 { |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1243 int w, h; |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1244 uint8_t *line1, *line2, *linesrc = dst->data[0]; |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1245 uint8_t *lum1, *lum2, *lumsrc = src->data[0]; |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1246 uint8_t *cb1, *cb2 = src->data[1]; |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1247 uint8_t *cr1, *cr2 = src->data[2]; |
2967 | 1248 |
2366
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1249 for(h = height / 2; h--;) { |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1250 line1 = linesrc; |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1251 line2 = linesrc + dst->linesize[0]; |
2967 | 1252 |
2366
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1253 lum1 = lumsrc; |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1254 lum2 = lumsrc + src->linesize[0]; |
2967 | 1255 |
2366
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1256 cb1 = cb2; |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1257 cr1 = cr2; |
2967 | 1258 |
2366
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1259 for(w = width / 2; w--;) { |
2967 | 1260 *line1++ = *line2++ = *cb1++; |
1261 *line1++ = *lum1++; *line2++ = *lum2++; | |
2366
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1262 *line1++ = *line2++ = *cr1++; |
2967 | 1263 *line1++ = *lum1++; *line2++ = *lum2++; |
2366
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1264 } |
2967 | 1265 |
2366
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1266 linesrc += dst->linesize[0] * 2; |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1267 lumsrc += src->linesize[0] * 2; |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1268 cb2 += src->linesize[1]; |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1269 cr2 += src->linesize[2]; |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1270 } |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1271 } |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1272 |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1273 /* 2x2 -> 1x1 */ |
3245 | 1274 void ff_shrink22(uint8_t *dst, int dst_wrap, |
1205 | 1275 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
|
1276 int width, int height) |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1277 { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1278 int w; |
1205 | 1279 const uint8_t *s1, *s2; |
1280 uint8_t *d; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1281 |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1282 for(;height > 0; height--) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1283 s1 = src; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1284 s2 = s1 + src_wrap; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1285 d = dst; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1286 for(w = width;w >= 4; w-=4) { |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
1287 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
|
1288 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
|
1289 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
|
1290 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
|
1291 s1 += 8; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1292 s2 += 8; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1293 d += 4; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1294 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1295 for(;w > 0; w--) { |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
1296 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
|
1297 s1 += 2; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1298 s2 += 2; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1299 d++; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1300 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1301 src += 2 * src_wrap; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1302 dst += dst_wrap; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1303 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1304 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1305 |
1205 | 1306 /* 4x4 -> 1x1 */ |
3245 | 1307 void ff_shrink44(uint8_t *dst, int dst_wrap, |
1205 | 1308 const uint8_t *src, int src_wrap, |
576
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1309 int width, int height) |
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1310 { |
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1311 int w; |
1205 | 1312 const uint8_t *s1, *s2, *s3, *s4; |
1313 uint8_t *d; | |
576
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1314 |
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1315 for(;height > 0; height--) { |
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1316 s1 = src; |
1205 | 1317 s2 = s1 + src_wrap; |
1318 s3 = s2 + src_wrap; | |
1319 s4 = s3 + src_wrap; | |
576
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1320 d = dst; |
1205 | 1321 for(w = width;w > 0; w--) { |
1322 d[0] = (s1[0] + s1[1] + s1[2] + s1[3] + | |
1323 s2[0] + s2[1] + s2[2] + s2[3] + | |
1324 s3[0] + s3[1] + s3[2] + s3[3] + | |
1325 s4[0] + s4[1] + s4[2] + s4[3] + 8) >> 4; | |
1326 s1 += 4; | |
1327 s2 += 4; | |
1328 s3 += 4; | |
1329 s4 += 4; | |
576
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1330 d++; |
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1331 } |
1205 | 1332 src += 4 * src_wrap; |
1333 dst += dst_wrap; | |
1334 } | |
1335 } | |
1336 | |
3245 | 1337 /* 8x8 -> 1x1 */ |
1338 void ff_shrink88(uint8_t *dst, int dst_wrap, | |
1339 const uint8_t *src, int src_wrap, | |
1340 int width, int height) | |
1341 { | |
1342 int w, i; | |
1343 | |
1344 for(;height > 0; height--) { | |
1345 for(w = width;w > 0; w--) { | |
1346 int tmp=0; | |
1347 for(i=0; i<8; i++){ | |
1348 tmp += src[0] + src[1] + src[2] + src[3] + src[4] + src[5] + src[6] + src[7]; | |
1349 src += src_wrap; | |
1350 } | |
1351 *(dst++) = (tmp + 32)>>6; | |
1352 src += 8 - 8*src_wrap; | |
1353 } | |
1354 src += 8*src_wrap - 8*width; | |
1355 dst += dst_wrap - width; | |
1356 } | |
1357 } | |
1358 | |
1204 | 1359 /* XXX: add jpeg quantize code */ |
1360 | |
1361 #define TRANSP_INDEX (6*6*6) | |
1362 | |
1363 /* this is maybe slow, but allows for extensions */ | |
1364 static inline unsigned char gif_clut_index(uint8_t r, uint8_t g, uint8_t b) | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1365 { |
6750 | 1366 return (((r) / 47) % 6) * 6 * 6 + (((g) / 47) % 6) * 6 + (((b) / 47) % 6); |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1367 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1368 |
1204 | 1369 static void build_rgb_palette(uint8_t *palette, int has_alpha) |
1370 { | |
1371 uint32_t *pal; | |
1372 static const uint8_t pal_value[6] = { 0x00, 0x33, 0x66, 0x99, 0xcc, 0xff }; | |
1373 int i, r, g, b; | |
1374 | |
1375 pal = (uint32_t *)palette; | |
1376 i = 0; | |
1377 for(r = 0; r < 6; r++) { | |
1378 for(g = 0; g < 6; g++) { | |
1379 for(b = 0; b < 6; b++) { | |
2967 | 1380 pal[i++] = (0xff << 24) | (pal_value[r] << 16) | |
1204 | 1381 (pal_value[g] << 8) | pal_value[b]; |
1382 } | |
1383 } | |
1384 } | |
1385 if (has_alpha) | |
1386 pal[i++] = 0; | |
1387 while (i < 256) | |
1388 pal[i++] = 0xff000000; | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1389 } |
583 | 1390 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1391 /* copy bit n to bits 0 ... n - 1 */ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1392 static inline unsigned int bitcopy_n(unsigned int a, int n) |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1393 { |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1394 int mask; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1395 mask = (1 << n) - 1; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1396 return (a & (0xff & ~mask)) | ((-((a >> n) & 1)) & mask); |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1397 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1398 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1399 /* rgb555 handling */ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1400 |
1204 | 1401 #define RGB_NAME rgb555 |
1402 | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1403 #define RGB_IN(r, g, b, s)\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1404 {\ |
1064 | 1405 unsigned int v = ((const uint16_t *)(s))[0];\ |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1406 r = bitcopy_n(v >> (10 - 3), 3);\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1407 g = bitcopy_n(v >> (5 - 3), 3);\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1408 b = bitcopy_n(v << 3, 3);\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1409 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1410 |
4208 | 1411 |
1412 #define RGB_OUT(d, r, g, b)\ | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1413 {\ |
4208 | 1414 ((uint16_t *)(d))[0] = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3);\ |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1415 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1416 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1417 #define BPP 2 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1418 |
1204 | 1419 #include "imgconvert_template.h" |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1420 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1421 /* rgb565 handling */ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1422 |
1204 | 1423 #define RGB_NAME rgb565 |
1424 | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1425 #define RGB_IN(r, g, b, s)\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1426 {\ |
1064 | 1427 unsigned int v = ((const uint16_t *)(s))[0];\ |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1428 r = bitcopy_n(v >> (11 - 3), 3);\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1429 g = bitcopy_n(v >> (5 - 2), 2);\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1430 b = bitcopy_n(v << 3, 3);\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1431 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1432 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1433 #define RGB_OUT(d, r, g, b)\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1434 {\ |
1064 | 1435 ((uint16_t *)(d))[0] = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);\ |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1436 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1437 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1438 #define BPP 2 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1439 |
1204 | 1440 #include "imgconvert_template.h" |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1441 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1442 /* bgr24 handling */ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1443 |
1204 | 1444 #define RGB_NAME bgr24 |
1445 | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1446 #define RGB_IN(r, g, b, s)\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1447 {\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1448 b = (s)[0];\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1449 g = (s)[1];\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1450 r = (s)[2];\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1451 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1452 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1453 #define RGB_OUT(d, r, g, b)\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1454 {\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1455 (d)[0] = b;\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1456 (d)[1] = g;\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1457 (d)[2] = r;\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1458 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1459 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1460 #define BPP 3 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1461 |
1204 | 1462 #include "imgconvert_template.h" |
583 | 1463 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1464 #undef RGB_IN |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1465 #undef RGB_OUT |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1466 #undef BPP |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1467 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1468 /* rgb24 handling */ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1469 |
1204 | 1470 #define RGB_NAME rgb24 |
1471 #define FMT_RGB24 | |
1472 | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1473 #define RGB_IN(r, g, b, s)\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1474 {\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1475 r = (s)[0];\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1476 g = (s)[1];\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1477 b = (s)[2];\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1478 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1479 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1480 #define RGB_OUT(d, r, g, b)\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1481 {\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1482 (d)[0] = r;\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1483 (d)[1] = g;\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1484 (d)[2] = b;\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1485 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1486 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1487 #define BPP 3 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1488 |
1204 | 1489 #include "imgconvert_template.h" |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1490 |
4515 | 1491 /* rgb32 handling */ |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1492 |
4515 | 1493 #define RGB_NAME rgb32 |
1494 #define FMT_RGB32 | |
1204 | 1495 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1496 #define RGB_IN(r, g, b, s)\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1497 {\ |
1064 | 1498 unsigned int v = ((const uint32_t *)(s))[0];\ |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1499 r = (v >> 16) & 0xff;\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1500 g = (v >> 8) & 0xff;\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1501 b = v & 0xff;\ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1502 } |
583 | 1503 |
1204 | 1504 #define RGBA_IN(r, g, b, a, s)\ |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1505 {\ |
1204 | 1506 unsigned int v = ((const uint32_t *)(s))[0];\ |
1507 a = (v >> 24) & 0xff;\ | |
1508 r = (v >> 16) & 0xff;\ | |
1509 g = (v >> 8) & 0xff;\ | |
1510 b = v & 0xff;\ | |
1511 } | |
1512 | |
1513 #define RGBA_OUT(d, r, g, b, a)\ | |
1514 {\ | |
1515 ((uint32_t *)(d))[0] = (a << 24) | (r << 16) | (g << 8) | b;\ | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1516 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1517 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1518 #define BPP 4 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1519 |
1204 | 1520 #include "imgconvert_template.h" |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1521 |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1522 static void mono_to_gray(AVPicture *dst, const AVPicture *src, |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1523 int width, int height, int xor_mask) |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1524 { |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1525 const unsigned char *p; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1526 unsigned char *q; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1527 int v, dst_wrap, src_wrap; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1528 int y, w; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1529 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1530 p = src->data[0]; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1531 src_wrap = src->linesize[0] - ((width + 7) >> 3); |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1532 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1533 q = dst->data[0]; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1534 dst_wrap = dst->linesize[0] - width; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1535 for(y=0;y<height;y++) { |
2967 | 1536 w = width; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1537 while (w >= 8) { |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1538 v = *p++ ^ xor_mask; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1539 q[0] = -(v >> 7); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1540 q[1] = -((v >> 6) & 1); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1541 q[2] = -((v >> 5) & 1); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1542 q[3] = -((v >> 4) & 1); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1543 q[4] = -((v >> 3) & 1); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1544 q[5] = -((v >> 2) & 1); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1545 q[6] = -((v >> 1) & 1); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1546 q[7] = -((v >> 0) & 1); |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1547 w -= 8; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1548 q += 8; |
583 | 1549 } |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1550 if (w > 0) { |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1551 v = *p++ ^ xor_mask; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1552 do { |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1553 q[0] = -((v >> 7) & 1); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1554 q++; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1555 v <<= 1; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1556 } while (--w); |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1557 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1558 p += src_wrap; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1559 q += dst_wrap; |
583 | 1560 } |
1561 } | |
1562 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1563 static void monowhite_to_gray(AVPicture *dst, const AVPicture *src, |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1564 int width, int height) |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1565 { |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1566 mono_to_gray(dst, src, width, height, 0xff); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1567 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1568 |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1569 static void monoblack_to_gray(AVPicture *dst, const AVPicture *src, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1570 int width, int height) |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1571 { |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1572 mono_to_gray(dst, src, width, height, 0x00); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1573 } |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1574 |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1575 static void gray_to_mono(AVPicture *dst, const AVPicture *src, |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1576 int width, int height, int xor_mask) |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1577 { |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1578 int n; |
1064 | 1579 const uint8_t *s; |
1580 uint8_t *d; | |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1581 int j, b, v, n1, src_wrap, dst_wrap, y; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1582 |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1583 s = src->data[0]; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1584 src_wrap = src->linesize[0] - width; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1585 |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1586 d = dst->data[0]; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1587 dst_wrap = dst->linesize[0] - ((width + 7) >> 3); |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1588 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1589 for(y=0;y<height;y++) { |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1590 n = width; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1591 while (n >= 8) { |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1592 v = 0; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1593 for(j=0;j<8;j++) { |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1594 b = s[0]; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1595 s++; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1596 v = (v << 1) | (b >> 7); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1597 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1598 d[0] = v ^ xor_mask; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1599 d++; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1600 n -= 8; |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1601 } |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1602 if (n > 0) { |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1603 n1 = n; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1604 v = 0; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1605 while (n > 0) { |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1606 b = s[0]; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1607 s++; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1608 v = (v << 1) | (b >> 7); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1609 n--; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1610 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1611 d[0] = (v << (8 - (n1 & 7))) ^ xor_mask; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1612 d++; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1613 } |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1614 s += src_wrap; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1615 d += dst_wrap; |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1616 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1617 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1618 |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1619 static void gray_to_monowhite(AVPicture *dst, const AVPicture *src, |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1620 int width, int height) |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1621 { |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1622 gray_to_mono(dst, src, width, height, 0xff); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1623 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1624 |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1625 static void gray_to_monoblack(AVPicture *dst, const AVPicture *src, |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1626 int width, int height) |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1627 { |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1628 gray_to_mono(dst, src, width, height, 0x00); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1629 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1630 |
4066 | 1631 static void gray_to_gray16(AVPicture *dst, const AVPicture *src, |
1632 int width, int height) | |
1633 { | |
1634 int x, y, src_wrap, dst_wrap; | |
1635 uint8_t *s, *d; | |
1636 s = src->data[0]; | |
1637 src_wrap = src->linesize[0] - width; | |
1638 d = dst->data[0]; | |
1639 dst_wrap = dst->linesize[0] - width * 2; | |
1640 for(y=0; y<height; y++){ | |
1641 for(x=0; x<width; x++){ | |
1642 *d++ = *s; | |
1643 *d++ = *s++; | |
1644 } | |
1645 s += src_wrap; | |
1646 d += dst_wrap; | |
1647 } | |
1648 } | |
1649 | |
1650 static void gray16_to_gray(AVPicture *dst, const AVPicture *src, | |
1651 int width, int height) | |
1652 { | |
1653 int x, y, src_wrap, dst_wrap; | |
1654 uint8_t *s, *d; | |
1655 s = src->data[0]; | |
1656 src_wrap = src->linesize[0] - width * 2; | |
1657 d = dst->data[0]; | |
1658 dst_wrap = dst->linesize[0] - width; | |
1659 for(y=0; y<height; y++){ | |
1660 for(x=0; x<width; x++){ | |
1661 *d++ = *s; | |
1662 s += 2; | |
1663 } | |
1664 s += src_wrap; | |
1665 d += dst_wrap; | |
1666 } | |
1667 } | |
1668 | |
1669 static void gray16be_to_gray(AVPicture *dst, const AVPicture *src, | |
1670 int width, int height) | |
1671 { | |
1672 gray16_to_gray(dst, src, width, height); | |
1673 } | |
1674 | |
1675 static void gray16le_to_gray(AVPicture *dst, const AVPicture *src, | |
1676 int width, int height) | |
1677 { | |
4802
e02f7d142ce9
Fix segmentation fault for gray16le to gray conversion.
ivo
parents:
4624
diff
changeset
|
1678 AVPicture tmpsrc = *src; |
e02f7d142ce9
Fix segmentation fault for gray16le to gray conversion.
ivo
parents:
4624
diff
changeset
|
1679 tmpsrc.data[0]++; |
e02f7d142ce9
Fix segmentation fault for gray16le to gray conversion.
ivo
parents:
4624
diff
changeset
|
1680 gray16_to_gray(dst, &tmpsrc, width, height); |
4066 | 1681 } |
1682 | |
1683 static void gray16_to_gray16(AVPicture *dst, const AVPicture *src, | |
1684 int width, int height) | |
1685 { | |
1686 int x, y, src_wrap, dst_wrap; | |
1687 uint16_t *s, *d; | |
6198
e09251439406
cast to dest type, fix warning imgconvert.c:1958: warning: assignment from incompatible pointer type
bcoudurier
parents:
6040
diff
changeset
|
1688 s = (uint16_t*)src->data[0]; |
4066 | 1689 src_wrap = (src->linesize[0] - width * 2)/2; |
6198
e09251439406
cast to dest type, fix warning imgconvert.c:1958: warning: assignment from incompatible pointer type
bcoudurier
parents:
6040
diff
changeset
|
1690 d = (uint16_t*)dst->data[0]; |
4066 | 1691 dst_wrap = (dst->linesize[0] - width * 2)/2; |
1692 for(y=0; y<height; y++){ | |
1693 for(x=0; x<width; x++){ | |
1694 *d++ = bswap_16(*s++); | |
1695 } | |
1696 s += src_wrap; | |
1697 d += dst_wrap; | |
1698 } | |
1699 } | |
1700 | |
1701 | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1702 typedef struct ConvertEntry { |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1703 void (*convert)(AVPicture *dst, |
2979 | 1704 const AVPicture *src, int width, int height); |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1705 } ConvertEntry; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1706 |
5355 | 1707 /* Add each new conversion function in this table. In order to be able |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1708 to convert from any format to any format, the following constraints |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1709 must be satisfied: |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1710 |
2967 | 1711 - all FF_COLOR_RGB formats must convert to and from PIX_FMT_RGB24 |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1712 |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1713 - all FF_COLOR_GRAY formats must convert to and from PIX_FMT_GRAY8 |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1714 |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1715 - all FF_COLOR_RGB formats with alpha must convert to and from PIX_FMT_RGB32 |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1716 |
1205 | 1717 - PIX_FMT_YUV444P and PIX_FMT_YUVJ444P must convert to and from |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1718 PIX_FMT_RGB24. |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1719 |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1720 - PIX_FMT_422 must convert to and from PIX_FMT_422P. |
1205 | 1721 |
5963 | 1722 The other conversion functions are just optimizations for common cases. |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1723 */ |
3420 | 1724 static const ConvertEntry convert_table[PIX_FMT_NB][PIX_FMT_NB] = { |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1725 [PIX_FMT_YUV420P] = { |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1726 [PIX_FMT_YUYV422] = { |
4517 | 1727 .convert = yuv420p_to_yuyv422, |
2326
fe1986d6230f
YUV420P to YUV422 conversion routine by (Danny Laarmans <dlaarmans at androme dot com>)
michael
parents:
2320
diff
changeset
|
1728 }, |
2967 | 1729 [PIX_FMT_RGB555] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1730 .convert = yuv420p_to_rgb555 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1731 }, |
2967 | 1732 [PIX_FMT_RGB565] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1733 .convert = yuv420p_to_rgb565 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1734 }, |
2967 | 1735 [PIX_FMT_BGR24] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1736 .convert = yuv420p_to_bgr24 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1737 }, |
2967 | 1738 [PIX_FMT_RGB24] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1739 .convert = yuv420p_to_rgb24 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1740 }, |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1741 [PIX_FMT_RGB32] = { |
4515 | 1742 .convert = yuv420p_to_rgb32 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1743 }, |
2979 | 1744 [PIX_FMT_UYVY422] = { |
2366
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1745 .convert = yuv420p_to_uyvy422, |
270666128b07
YUV420P to UYVY422 conversion patch by (Luca Abeni <lucabe72 >< email >< it>)
michael
parents:
2326
diff
changeset
|
1746 }, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1747 }, |
2967 | 1748 [PIX_FMT_YUV422P] = { |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1749 [PIX_FMT_YUYV422] = { |
4517 | 1750 .convert = yuv422p_to_yuyv422, |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1751 }, |
2967 | 1752 [PIX_FMT_UYVY422] = { |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1753 .convert = yuv422p_to_uyvy422, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1754 }, |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1755 }, |
2967 | 1756 [PIX_FMT_YUV444P] = { |
1757 [PIX_FMT_RGB24] = { | |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1758 .convert = yuv444p_to_rgb24 |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1759 }, |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1760 }, |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1761 [PIX_FMT_YUVJ420P] = { |
2967 | 1762 [PIX_FMT_RGB555] = { |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1763 .convert = yuvj420p_to_rgb555 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1764 }, |
2967 | 1765 [PIX_FMT_RGB565] = { |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1766 .convert = yuvj420p_to_rgb565 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1767 }, |
2967 | 1768 [PIX_FMT_BGR24] = { |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1769 .convert = yuvj420p_to_bgr24 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1770 }, |
2967 | 1771 [PIX_FMT_RGB24] = { |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1772 .convert = yuvj420p_to_rgb24 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1773 }, |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1774 [PIX_FMT_RGB32] = { |
4515 | 1775 .convert = yuvj420p_to_rgb32 |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1776 }, |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1777 }, |
2967 | 1778 [PIX_FMT_YUVJ444P] = { |
1779 [PIX_FMT_RGB24] = { | |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1780 .convert = yuvj444p_to_rgb24 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1781 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1782 }, |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1783 [PIX_FMT_YUYV422] = { |
2967 | 1784 [PIX_FMT_YUV420P] = { |
4517 | 1785 .convert = yuyv422_to_yuv420p, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1786 }, |
2967 | 1787 [PIX_FMT_YUV422P] = { |
4517 | 1788 .convert = yuyv422_to_yuv422p, |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1789 }, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1790 }, |
2967 | 1791 [PIX_FMT_UYVY422] = { |
1792 [PIX_FMT_YUV420P] = { | |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1793 .convert = uyvy422_to_yuv420p, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1794 }, |
2967 | 1795 [PIX_FMT_YUV422P] = { |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1796 .convert = uyvy422_to_yuv422p, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1797 }, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1798 }, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1799 [PIX_FMT_RGB24] = { |
2967 | 1800 [PIX_FMT_YUV420P] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1801 .convert = rgb24_to_yuv420p |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1802 }, |
2967 | 1803 [PIX_FMT_RGB565] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1804 .convert = rgb24_to_rgb565 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1805 }, |
2967 | 1806 [PIX_FMT_RGB555] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1807 .convert = rgb24_to_rgb555 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1808 }, |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1809 [PIX_FMT_RGB32] = { |
4515 | 1810 .convert = rgb24_to_rgb32 |
1204 | 1811 }, |
2967 | 1812 [PIX_FMT_BGR24] = { |
1204 | 1813 .convert = rgb24_to_bgr24 |
1814 }, | |
2967 | 1815 [PIX_FMT_GRAY8] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1816 .convert = rgb24_to_gray |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1817 }, |
1204 | 1818 [PIX_FMT_PAL8] = { |
1055 | 1819 .convert = rgb24_to_pal8 |
1820 }, | |
2967 | 1821 [PIX_FMT_YUV444P] = { |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1822 .convert = rgb24_to_yuv444p |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1823 }, |
2967 | 1824 [PIX_FMT_YUVJ420P] = { |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1825 .convert = rgb24_to_yuvj420p |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1826 }, |
2967 | 1827 [PIX_FMT_YUVJ444P] = { |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1828 .convert = rgb24_to_yuvj444p |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1829 }, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1830 }, |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1831 [PIX_FMT_RGB32] = { |
2967 | 1832 [PIX_FMT_RGB24] = { |
4515 | 1833 .convert = rgb32_to_rgb24 |
1204 | 1834 }, |
4201
c4f87cfd5b20
changed rgba32_to routines to support both alpha and non-alpha formats (see r7066 too)
alex
parents:
4176
diff
changeset
|
1835 [PIX_FMT_BGR24] = { |
4515 | 1836 .convert = rgb32_to_bgr24 |
4201
c4f87cfd5b20
changed rgba32_to routines to support both alpha and non-alpha formats (see r7066 too)
alex
parents:
4176
diff
changeset
|
1837 }, |
c4f87cfd5b20
changed rgba32_to routines to support both alpha and non-alpha formats (see r7066 too)
alex
parents:
4176
diff
changeset
|
1838 [PIX_FMT_RGB565] = { |
4515 | 1839 .convert = rgb32_to_rgb565 |
4201
c4f87cfd5b20
changed rgba32_to routines to support both alpha and non-alpha formats (see r7066 too)
alex
parents:
4176
diff
changeset
|
1840 }, |
2967 | 1841 [PIX_FMT_RGB555] = { |
4515 | 1842 .convert = rgb32_to_rgb555 |
1204 | 1843 }, |
2967 | 1844 [PIX_FMT_PAL8] = { |
4515 | 1845 .convert = rgb32_to_pal8 |
1204 | 1846 }, |
2967 | 1847 [PIX_FMT_YUV420P] = { |
4515 | 1848 .convert = rgb32_to_yuv420p |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1849 }, |
2967 | 1850 [PIX_FMT_GRAY8] = { |
4515 | 1851 .convert = rgb32_to_gray |
1022
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
1852 }, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1853 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1854 [PIX_FMT_BGR24] = { |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1855 [PIX_FMT_RGB32] = { |
4515 | 1856 .convert = bgr24_to_rgb32 |
4201
c4f87cfd5b20
changed rgba32_to routines to support both alpha and non-alpha formats (see r7066 too)
alex
parents:
4176
diff
changeset
|
1857 }, |
2967 | 1858 [PIX_FMT_RGB24] = { |
1204 | 1859 .convert = bgr24_to_rgb24 |
1860 }, | |
2967 | 1861 [PIX_FMT_YUV420P] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1862 .convert = bgr24_to_yuv420p |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1863 }, |
2967 | 1864 [PIX_FMT_GRAY8] = { |
1022
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
1865 .convert = bgr24_to_gray |
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
1866 }, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1867 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1868 [PIX_FMT_RGB555] = { |
2967 | 1869 [PIX_FMT_RGB24] = { |
1204 | 1870 .convert = rgb555_to_rgb24 |
1871 }, | |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1872 [PIX_FMT_RGB32] = { |
4515 | 1873 .convert = rgb555_to_rgb32 |
1204 | 1874 }, |
2967 | 1875 [PIX_FMT_YUV420P] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1876 .convert = rgb555_to_yuv420p |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1877 }, |
2967 | 1878 [PIX_FMT_GRAY8] = { |
1022
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
1879 .convert = rgb555_to_gray |
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
1880 }, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1881 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1882 [PIX_FMT_RGB565] = { |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1883 [PIX_FMT_RGB32] = { |
4515 | 1884 .convert = rgb565_to_rgb32 |
4201
c4f87cfd5b20
changed rgba32_to routines to support both alpha and non-alpha formats (see r7066 too)
alex
parents:
4176
diff
changeset
|
1885 }, |
2967 | 1886 [PIX_FMT_RGB24] = { |
1204 | 1887 .convert = rgb565_to_rgb24 |
1888 }, | |
2967 | 1889 [PIX_FMT_YUV420P] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1890 .convert = rgb565_to_yuv420p |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1891 }, |
2967 | 1892 [PIX_FMT_GRAY8] = { |
1022
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
1893 .convert = rgb565_to_gray |
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
1894 }, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1895 }, |
4066 | 1896 [PIX_FMT_GRAY16BE] = { |
1897 [PIX_FMT_GRAY8] = { | |
1898 .convert = gray16be_to_gray | |
1899 }, | |
1900 [PIX_FMT_GRAY16LE] = { | |
1901 .convert = gray16_to_gray16 | |
1902 }, | |
1903 }, | |
1904 [PIX_FMT_GRAY16LE] = { | |
1905 [PIX_FMT_GRAY8] = { | |
1906 .convert = gray16le_to_gray | |
1907 }, | |
1908 [PIX_FMT_GRAY16BE] = { | |
1909 .convert = gray16_to_gray16 | |
1910 }, | |
1911 }, | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1912 [PIX_FMT_GRAY8] = { |
2967 | 1913 [PIX_FMT_RGB555] = { |
1022
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
1914 .convert = gray_to_rgb555 |
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
1915 }, |
2967 | 1916 [PIX_FMT_RGB565] = { |
1022
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
1917 .convert = gray_to_rgb565 |
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
1918 }, |
2967 | 1919 [PIX_FMT_RGB24] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1920 .convert = gray_to_rgb24 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1921 }, |
2967 | 1922 [PIX_FMT_BGR24] = { |
1022
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
1923 .convert = gray_to_bgr24 |
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
1924 }, |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1925 [PIX_FMT_RGB32] = { |
4515 | 1926 .convert = gray_to_rgb32 |
1022
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
1927 }, |
2967 | 1928 [PIX_FMT_MONOWHITE] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1929 .convert = gray_to_monowhite |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1930 }, |
2967 | 1931 [PIX_FMT_MONOBLACK] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1932 .convert = gray_to_monoblack |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1933 }, |
4066 | 1934 [PIX_FMT_GRAY16LE] = { |
1935 .convert = gray_to_gray16 | |
1936 }, | |
1937 [PIX_FMT_GRAY16BE] = { | |
1938 .convert = gray_to_gray16 | |
1939 }, | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1940 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1941 [PIX_FMT_MONOWHITE] = { |
2967 | 1942 [PIX_FMT_GRAY8] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1943 .convert = monowhite_to_gray |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1944 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1945 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1946 [PIX_FMT_MONOBLACK] = { |
2967 | 1947 [PIX_FMT_GRAY8] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
1948 .convert = monoblack_to_gray |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1949 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1950 }, |
1055 | 1951 [PIX_FMT_PAL8] = { |
2967 | 1952 [PIX_FMT_RGB555] = { |
1055 | 1953 .convert = pal8_to_rgb555 |
1954 }, | |
2967 | 1955 [PIX_FMT_RGB565] = { |
1055 | 1956 .convert = pal8_to_rgb565 |
1957 }, | |
2967 | 1958 [PIX_FMT_BGR24] = { |
1055 | 1959 .convert = pal8_to_bgr24 |
1960 }, | |
2967 | 1961 [PIX_FMT_RGB24] = { |
1055 | 1962 .convert = pal8_to_rgb24 |
1963 }, | |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1964 [PIX_FMT_RGB32] = { |
4515 | 1965 .convert = pal8_to_rgb32 |
1055 | 1966 }, |
1967 }, | |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1968 [PIX_FMT_UYYVYY411] = { |
2967 | 1969 [PIX_FMT_YUV411P] = { |
4516 | 1970 .convert = uyyvyy411_to_yuv411p, |
2309 | 1971 }, |
1972 }, | |
1973 | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1974 }; |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1975 |
1508 | 1976 int avpicture_alloc(AVPicture *picture, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1977 int pix_fmt, int width, int height) |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1978 { |
3266
3b785e80ce3e
make "size" variable in avpicture_alloc signed, since avpicture_get_size
reimar
parents:
3257
diff
changeset
|
1979 int size; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1980 void *ptr; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1981 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1982 size = avpicture_get_size(pix_fmt, width, height); |
2422 | 1983 if(size<0) |
1984 goto fail; | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1985 ptr = av_malloc(size); |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1986 if (!ptr) |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1987 goto fail; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1988 avpicture_fill(picture, ptr, pix_fmt, width, height); |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1989 return 0; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1990 fail: |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1991 memset(picture, 0, sizeof(AVPicture)); |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1992 return -1; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1993 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1994 |
1508 | 1995 void avpicture_free(AVPicture *picture) |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1996 { |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
1028
diff
changeset
|
1997 av_free(picture->data[0]); |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1998 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1999 |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2000 /* return true if yuv planar */ |
3420 | 2001 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
|
2002 { |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2003 return (ps->color_type == FF_COLOR_YUV || |
2967 | 2004 ps->color_type == FF_COLOR_YUV_JPEG) && |
1204 | 2005 ps->pixel_type == FF_PIXEL_PLANAR; |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2006 } |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2007 |
4624
6a900f539e2c
Add the prefix "av_" to img_crop(), img_copy() and img_pad(), and rename "img"
takis
parents:
4593
diff
changeset
|
2008 int av_picture_crop(AVPicture *dst, const AVPicture *src, |
3179 | 2009 int pix_fmt, int top_band, int left_band) |
2010 { | |
2011 int y_shift; | |
2012 int x_shift; | |
2013 | |
2014 if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB || !is_yuv_planar(&pix_fmt_info[pix_fmt])) | |
2015 return -1; | |
2016 | |
2017 y_shift = pix_fmt_info[pix_fmt].y_chroma_shift; | |
2018 x_shift = pix_fmt_info[pix_fmt].x_chroma_shift; | |
2019 | |
2020 dst->data[0] = src->data[0] + (top_band * src->linesize[0]) + left_band; | |
2021 dst->data[1] = src->data[1] + ((top_band >> y_shift) * src->linesize[1]) + (left_band >> x_shift); | |
2022 dst->data[2] = src->data[2] + ((top_band >> y_shift) * src->linesize[2]) + (left_band >> x_shift); | |
2023 | |
2024 dst->linesize[0] = src->linesize[0]; | |
2025 dst->linesize[1] = src->linesize[1]; | |
2026 dst->linesize[2] = src->linesize[2]; | |
2027 return 0; | |
2028 } | |
2029 | |
4624
6a900f539e2c
Add the prefix "av_" to img_crop(), img_copy() and img_pad(), and rename "img"
takis
parents:
4593
diff
changeset
|
2030 int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, |
4358 | 2031 int pix_fmt, int padtop, int padbottom, int padleft, int padright, |
2032 int *color) | |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2033 { |
4359
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
2034 uint8_t *optr; |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2035 int y_shift; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2036 int x_shift; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2037 int yheight; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2038 int i, y; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2039 |
4358 | 2040 if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB || |
2041 !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
|
2042 |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2043 for (i = 0; i < 3; i++) { |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2044 x_shift = i ? pix_fmt_info[pix_fmt].x_chroma_shift : 0; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2045 y_shift = i ? pix_fmt_info[pix_fmt].y_chroma_shift : 0; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2046 |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2047 if (padtop || padleft) { |
4358 | 2048 memset(dst->data[i], color[i], |
2049 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
|
2050 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2051 |
4359
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
2052 if (padleft || padright) { |
4358 | 2053 optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) + |
2054 (dst->linesize[i] - (padright >> x_shift)); | |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2055 yheight = (height - 1 - (padtop + padbottom)) >> y_shift; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2056 for (y = 0; y < yheight; y++) { |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2057 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
|
2058 optr += dst->linesize[i]; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
2059 } |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
2060 } |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
2061 |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
2062 if (src) { /* first line */ |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
2063 uint8_t *iptr = src->data[i]; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
2064 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
|
2065 (padleft >> x_shift); |
6963
cc2c5a21a0eb
memcpy considering output width, not src linesize, fix segv with av_picture_pad
bcoudurier
parents:
6911
diff
changeset
|
2066 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
|
2067 iptr += src->linesize[i]; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
2068 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
|
2069 (dst->linesize[i] - (padright >> x_shift)); |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
2070 yheight = (height - 1 - (padtop + padbottom)) >> y_shift; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
2071 for (y = 0; y < yheight; y++) { |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
2072 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
|
2073 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
|
2074 (width - padleft - padright) >> x_shift); |
4359
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
2075 iptr += src->linesize[i]; |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2076 optr += dst->linesize[i]; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2077 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2078 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2079 |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2080 if (padbottom || padright) { |
4358 | 2081 optr = dst->data[i] + dst->linesize[i] * |
2082 ((height - padbottom) >> y_shift) - (padright >> x_shift); | |
2083 memset(optr, color[i],dst->linesize[i] * | |
2084 (padbottom >> y_shift) + (padright >> x_shift)); | |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2085 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2086 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2087 return 0; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2088 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
2089 |
6485
949e4f444a50
Rename --enable-swscaler --> enable-swscale to be consistent with the
diego
parents:
6358
diff
changeset
|
2090 #ifndef CONFIG_SWSCALE |
6499
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2091 static uint8_t y_ccir_to_jpeg[256]; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2092 static uint8_t y_jpeg_to_ccir[256]; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2093 static uint8_t c_ccir_to_jpeg[256]; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2094 static uint8_t c_jpeg_to_ccir[256]; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2095 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2096 /* init various conversion tables */ |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2097 static void img_convert_init(void) |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2098 { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2099 int i; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2100 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2101 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2102 for(i = 0;i < 256; i++) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2103 y_ccir_to_jpeg[i] = Y_CCIR_TO_JPEG(i); |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2104 y_jpeg_to_ccir[i] = Y_JPEG_TO_CCIR(i); |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2105 c_ccir_to_jpeg[i] = C_CCIR_TO_JPEG(i); |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2106 c_jpeg_to_ccir[i] = C_JPEG_TO_CCIR(i); |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2107 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2108 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2109 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2110 /* apply to each pixel the given table */ |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2111 static void img_apply_table(uint8_t *dst, int dst_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2112 const uint8_t *src, int src_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2113 int width, int height, const uint8_t *table1) |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2114 { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2115 int n; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2116 const uint8_t *s; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2117 uint8_t *d; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2118 const uint8_t *table; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2119 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2120 table = table1; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2121 for(;height > 0; height--) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2122 s = src; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2123 d = dst; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2124 n = width; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2125 while (n >= 4) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2126 d[0] = table[s[0]]; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2127 d[1] = table[s[1]]; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2128 d[2] = table[s[2]]; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2129 d[3] = table[s[3]]; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2130 d += 4; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2131 s += 4; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2132 n -= 4; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2133 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2134 while (n > 0) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2135 d[0] = table[s[0]]; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2136 d++; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2137 s++; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2138 n--; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2139 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2140 dst += dst_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2141 src += src_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2142 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2143 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2144 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2145 /* XXX: use generic filter ? */ |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2146 /* XXX: in most cases, the sampling position is incorrect */ |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2147 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2148 /* 4x1 -> 1x1 */ |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2149 static void shrink41(uint8_t *dst, int dst_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2150 const uint8_t *src, int src_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2151 int width, int height) |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2152 { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2153 int w; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2154 const uint8_t *s; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2155 uint8_t *d; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2156 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2157 for(;height > 0; height--) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2158 s = src; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2159 d = dst; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2160 for(w = width;w > 0; w--) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2161 d[0] = (s[0] + s[1] + s[2] + s[3] + 2) >> 2; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2162 s += 4; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2163 d++; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2164 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2165 src += src_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2166 dst += dst_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2167 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2168 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2169 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2170 /* 2x1 -> 1x1 */ |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2171 static void shrink21(uint8_t *dst, int dst_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2172 const uint8_t *src, int src_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2173 int width, int height) |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2174 { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2175 int w; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2176 const uint8_t *s; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2177 uint8_t *d; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2178 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2179 for(;height > 0; height--) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2180 s = src; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2181 d = dst; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2182 for(w = width;w > 0; w--) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2183 d[0] = (s[0] + s[1]) >> 1; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2184 s += 2; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2185 d++; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2186 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2187 src += src_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2188 dst += dst_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2189 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2190 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2191 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2192 /* 1x2 -> 1x1 */ |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2193 static void shrink12(uint8_t *dst, int dst_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2194 const uint8_t *src, int src_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2195 int width, int height) |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2196 { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2197 int w; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2198 uint8_t *d; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2199 const uint8_t *s1, *s2; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2200 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2201 for(;height > 0; height--) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2202 s1 = src; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2203 s2 = s1 + src_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2204 d = dst; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2205 for(w = width;w >= 4; w-=4) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2206 d[0] = (s1[0] + s2[0]) >> 1; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2207 d[1] = (s1[1] + s2[1]) >> 1; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2208 d[2] = (s1[2] + s2[2]) >> 1; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2209 d[3] = (s1[3] + s2[3]) >> 1; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2210 s1 += 4; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2211 s2 += 4; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2212 d += 4; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2213 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2214 for(;w > 0; w--) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2215 d[0] = (s1[0] + s2[0]) >> 1; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2216 s1++; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2217 s2++; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2218 d++; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2219 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2220 src += 2 * src_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2221 dst += dst_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2222 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2223 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2224 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2225 static void grow21_line(uint8_t *dst, const uint8_t *src, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2226 int width) |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2227 { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2228 int w; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2229 const uint8_t *s1; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2230 uint8_t *d; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2231 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2232 s1 = src; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2233 d = dst; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2234 for(w = width;w >= 4; w-=4) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2235 d[1] = d[0] = s1[0]; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2236 d[3] = d[2] = s1[1]; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2237 s1 += 2; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2238 d += 4; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2239 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2240 for(;w >= 2; w -= 2) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2241 d[1] = d[0] = s1[0]; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2242 s1 ++; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2243 d += 2; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2244 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2245 /* only needed if width is not a multiple of two */ |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2246 /* XXX: veryfy that */ |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2247 if (w) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2248 d[0] = s1[0]; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2249 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2250 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2251 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2252 static void grow41_line(uint8_t *dst, const uint8_t *src, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2253 int width) |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2254 { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2255 int w, v; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2256 const uint8_t *s1; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2257 uint8_t *d; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2258 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2259 s1 = src; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2260 d = dst; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2261 for(w = width;w >= 4; w-=4) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2262 v = s1[0]; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2263 d[0] = v; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2264 d[1] = v; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2265 d[2] = v; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2266 d[3] = v; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2267 s1 ++; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2268 d += 4; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2269 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2270 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2271 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2272 /* 1x1 -> 2x1 */ |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2273 static void grow21(uint8_t *dst, int dst_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2274 const uint8_t *src, int src_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2275 int width, int height) |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2276 { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2277 for(;height > 0; height--) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2278 grow21_line(dst, src, width); |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2279 src += src_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2280 dst += dst_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2281 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2282 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2283 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2284 /* 1x1 -> 1x2 */ |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2285 static void grow12(uint8_t *dst, int dst_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2286 const uint8_t *src, int src_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2287 int width, int height) |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2288 { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2289 for(;height > 0; height-=2) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2290 memcpy(dst, src, width); |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2291 dst += dst_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2292 memcpy(dst, src, width); |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2293 dst += dst_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2294 src += src_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2295 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2296 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2297 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2298 /* 1x1 -> 2x2 */ |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2299 static void grow22(uint8_t *dst, int dst_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2300 const uint8_t *src, int src_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2301 int width, int height) |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2302 { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2303 for(;height > 0; height--) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2304 grow21_line(dst, src, width); |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2305 if (height%2) |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2306 src += src_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2307 dst += dst_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2308 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2309 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2310 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2311 /* 1x1 -> 4x1 */ |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2312 static void grow41(uint8_t *dst, int dst_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2313 const uint8_t *src, int src_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2314 int width, int height) |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2315 { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2316 for(;height > 0; height--) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2317 grow41_line(dst, src, width); |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2318 src += src_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2319 dst += dst_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2320 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2321 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2322 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2323 /* 1x1 -> 4x4 */ |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2324 static void grow44(uint8_t *dst, int dst_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2325 const uint8_t *src, int src_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2326 int width, int height) |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2327 { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2328 for(;height > 0; height--) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2329 grow41_line(dst, src, width); |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2330 if ((height & 3) == 1) |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2331 src += src_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2332 dst += dst_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2333 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2334 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2335 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2336 /* 1x2 -> 2x1 */ |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2337 static void conv411(uint8_t *dst, int dst_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2338 const uint8_t *src, int src_wrap, |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2339 int width, int height) |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2340 { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2341 int w, c; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2342 const uint8_t *s1, *s2; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2343 uint8_t *d; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2344 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2345 width>>=1; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2346 |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2347 for(;height > 0; height--) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2348 s1 = src; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2349 s2 = src + src_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2350 d = dst; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2351 for(w = width;w > 0; w--) { |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2352 c = (s1[0] + s2[0]) >> 1; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2353 d[0] = c; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2354 d[1] = c; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2355 s1++; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2356 s2++; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2357 d += 2; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2358 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2359 src += src_wrap * 2; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2360 dst += dst_wrap; |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2361 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2362 } |
c9416ce3c09f
Move functions that are only used when libswscale is not compiled in below
diego
parents:
6485
diff
changeset
|
2363 |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2364 /* XXX: always use linesize. Return -1 if not supported */ |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2365 int img_convert(AVPicture *dst, int dst_pix_fmt, |
2967 | 2366 const AVPicture *src, int src_pix_fmt, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2367 int src_width, int src_height) |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2368 { |
6350 | 2369 static int initialized; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2370 int i, ret, dst_width, dst_height, int_pix_fmt; |
3420 | 2371 const PixFmtInfo *src_pix, *dst_pix; |
2372 const ConvertEntry *ce; | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2373 AVPicture tmp1, *tmp = &tmp1; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2374 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2375 if (src_pix_fmt < 0 || src_pix_fmt >= PIX_FMT_NB || |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2376 dst_pix_fmt < 0 || dst_pix_fmt >= PIX_FMT_NB) |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2377 return -1; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2378 if (src_width <= 0 || src_height <= 0) |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2379 return 0; |
1022
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
2380 |
6350 | 2381 if (!initialized) { |
2382 initialized = 1; | |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2383 img_convert_init(); |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2384 } |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2385 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2386 dst_width = src_width; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2387 dst_height = src_height; |
1022
d651df667898
added gray<->RGB functions - fixed rgb<->yuv functions for non RGB24 case
bellard
parents:
1020
diff
changeset
|
2388 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2389 dst_pix = &pix_fmt_info[dst_pix_fmt]; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2390 src_pix = &pix_fmt_info[src_pix_fmt]; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2391 if (src_pix_fmt == dst_pix_fmt) { |
1204 | 2392 /* no conversion needed: just copy */ |
4624
6a900f539e2c
Add the prefix "av_" to img_crop(), img_copy() and img_pad(), and rename "img"
takis
parents:
4593
diff
changeset
|
2393 av_picture_copy(dst, src, dst_pix_fmt, dst_width, dst_height); |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2394 return 0; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2395 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2396 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2397 ce = &convert_table[src_pix_fmt][dst_pix_fmt]; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2398 if (ce->convert) { |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
2399 /* specific conversion routine */ |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2400 ce->convert(dst, src, dst_width, dst_height); |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2401 return 0; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2402 } |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2403 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2404 /* gray to YUV */ |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2405 if (is_yuv_planar(dst_pix) && |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
2406 src_pix_fmt == PIX_FMT_GRAY8) { |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2407 int w, h, y; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2408 uint8_t *d; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2409 |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
2410 if (dst_pix->color_type == FF_COLOR_YUV_JPEG) { |
3245 | 2411 ff_img_copy_plane(dst->data[0], dst->linesize[0], |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
2412 src->data[0], src->linesize[0], |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
2413 dst_width, dst_height); |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
2414 } else { |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2415 img_apply_table(dst->data[0], dst->linesize[0], |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2416 src->data[0], src->linesize[0], |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2417 dst_width, dst_height, |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2418 y_jpeg_to_ccir); |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
2419 } |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2420 /* fill U and V with 128 */ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2421 w = dst_width; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2422 h = dst_height; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2423 w >>= dst_pix->x_chroma_shift; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2424 h >>= dst_pix->y_chroma_shift; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2425 for(i = 1; i <= 2; i++) { |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2426 d = dst->data[i]; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2427 for(y = 0; y< h; y++) { |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2428 memset(d, 128, w); |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2429 d += dst->linesize[i]; |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2430 } |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2431 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2432 return 0; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2433 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2434 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2435 /* YUV to gray */ |
2967 | 2436 if (is_yuv_planar(src_pix) && |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
2437 dst_pix_fmt == PIX_FMT_GRAY8) { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
2438 if (src_pix->color_type == FF_COLOR_YUV_JPEG) { |
3245 | 2439 ff_img_copy_plane(dst->data[0], dst->linesize[0], |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
2440 src->data[0], src->linesize[0], |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
2441 dst_width, dst_height); |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
2442 } else { |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2443 img_apply_table(dst->data[0], dst->linesize[0], |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2444 src->data[0], src->linesize[0], |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2445 dst_width, dst_height, |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2446 y_ccir_to_jpeg); |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
2447 } |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2448 return 0; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2449 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2450 |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2451 /* YUV to YUV planar */ |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2452 if (is_yuv_planar(dst_pix) && is_yuv_planar(src_pix)) { |
1205 | 2453 int x_shift, y_shift, w, h, xy_shift; |
2967 | 2454 void (*resize_func)(uint8_t *dst, int dst_wrap, |
1205 | 2455 const uint8_t *src, int src_wrap, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2456 int width, int height); |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2457 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2458 /* compute chroma size of the smallest dimensions */ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2459 w = dst_width; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2460 h = dst_height; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2461 if (dst_pix->x_chroma_shift >= src_pix->x_chroma_shift) |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2462 w >>= dst_pix->x_chroma_shift; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2463 else |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2464 w >>= src_pix->x_chroma_shift; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2465 if (dst_pix->y_chroma_shift >= src_pix->y_chroma_shift) |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2466 h >>= dst_pix->y_chroma_shift; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2467 else |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2468 h >>= src_pix->y_chroma_shift; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2469 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2470 x_shift = (dst_pix->x_chroma_shift - src_pix->x_chroma_shift); |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2471 y_shift = (dst_pix->y_chroma_shift - src_pix->y_chroma_shift); |
1205 | 2472 xy_shift = ((x_shift & 0xf) << 4) | (y_shift & 0xf); |
2473 /* there must be filters for conversion at least from and to | |
2474 YUV444 format */ | |
2475 switch(xy_shift) { | |
2476 case 0x00: | |
3245 | 2477 resize_func = ff_img_copy_plane; |
1205 | 2478 break; |
2479 case 0x10: | |
2480 resize_func = shrink21; | |
2481 break; | |
2482 case 0x20: | |
2483 resize_func = shrink41; | |
2484 break; | |
2485 case 0x01: | |
2486 resize_func = shrink12; | |
2487 break; | |
2488 case 0x11: | |
3245 | 2489 resize_func = ff_shrink22; |
1205 | 2490 break; |
2491 case 0x22: | |
3245 | 2492 resize_func = ff_shrink44; |
1205 | 2493 break; |
2494 case 0xf0: | |
2495 resize_func = grow21; | |
2496 break; | |
5363 | 2497 case 0x0f: |
2498 resize_func = grow12; | |
2499 break; | |
1205 | 2500 case 0xe0: |
2501 resize_func = grow41; | |
2502 break; | |
2503 case 0xff: | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2504 resize_func = grow22; |
1205 | 2505 break; |
2506 case 0xee: | |
2507 resize_func = grow44; | |
2508 break; | |
2509 case 0xf1: | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2510 resize_func = conv411; |
1205 | 2511 break; |
2512 default: | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2513 /* currently not handled */ |
1205 | 2514 goto no_chroma_filter; |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2515 } |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2516 |
3245 | 2517 ff_img_copy_plane(dst->data[0], dst->linesize[0], |
1204 | 2518 src->data[0], src->linesize[0], |
2519 dst_width, dst_height); | |
1023
e61be5796027
img_convert() (YUV to YUV) patch by (Max Krasnyansky <maxk at qualcomm dot com>)
michaelni
parents:
1022
diff
changeset
|
2520 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2521 for(i = 1;i <= 2; i++) |
1023
e61be5796027
img_convert() (YUV to YUV) patch by (Max Krasnyansky <maxk at qualcomm dot com>)
michaelni
parents:
1022
diff
changeset
|
2522 resize_func(dst->data[i], dst->linesize[i], |
e61be5796027
img_convert() (YUV to YUV) patch by (Max Krasnyansky <maxk at qualcomm dot com>)
michaelni
parents:
1022
diff
changeset
|
2523 src->data[i], src->linesize[i], |
1073 | 2524 dst_width>>dst_pix->x_chroma_shift, dst_height>>dst_pix->y_chroma_shift); |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2525 /* if yuv color space conversion is needed, we do it here on |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2526 the destination image */ |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2527 if (dst_pix->color_type != src_pix->color_type) { |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2528 const uint8_t *y_table, *c_table; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2529 if (dst_pix->color_type == FF_COLOR_YUV) { |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2530 y_table = y_jpeg_to_ccir; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2531 c_table = c_jpeg_to_ccir; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2532 } else { |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2533 y_table = y_ccir_to_jpeg; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2534 c_table = c_ccir_to_jpeg; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2535 } |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2536 img_apply_table(dst->data[0], dst->linesize[0], |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2537 dst->data[0], dst->linesize[0], |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2538 dst_width, dst_height, |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2539 y_table); |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2540 |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2541 for(i = 1;i <= 2; i++) |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2542 img_apply_table(dst->data[i], dst->linesize[i], |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2543 dst->data[i], dst->linesize[i], |
2967 | 2544 dst_width>>dst_pix->x_chroma_shift, |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2545 dst_height>>dst_pix->y_chroma_shift, |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2546 c_table); |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2547 } |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2548 return 0; |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2549 } |
1205 | 2550 no_chroma_filter: |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
2551 |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2552 /* try to use an intermediate format */ |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
2553 if (src_pix_fmt == PIX_FMT_YUYV422 || |
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
2554 dst_pix_fmt == PIX_FMT_YUYV422) { |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2555 /* specific case: convert to YUV422P first */ |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2556 int_pix_fmt = PIX_FMT_YUV422P; |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
2557 } else if (src_pix_fmt == PIX_FMT_UYVY422 || |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
2558 dst_pix_fmt == PIX_FMT_UYVY422) { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
2559 /* specific case: convert to YUV422P first */ |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
2560 int_pix_fmt = PIX_FMT_YUV422P; |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
2561 } else if (src_pix_fmt == PIX_FMT_UYYVYY411 || |
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
2562 dst_pix_fmt == PIX_FMT_UYYVYY411) { |
2309 | 2563 /* specific case: convert to YUV411P first */ |
2564 int_pix_fmt = PIX_FMT_YUV411P; | |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2565 } else if ((src_pix->color_type == FF_COLOR_GRAY && |
2967 | 2566 src_pix_fmt != PIX_FMT_GRAY8) || |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2567 (dst_pix->color_type == FF_COLOR_GRAY && |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2568 dst_pix_fmt != PIX_FMT_GRAY8)) { |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2569 /* gray8 is the normalized format */ |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2570 int_pix_fmt = PIX_FMT_GRAY8; |
2967 | 2571 } else if ((is_yuv_planar(src_pix) && |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2572 src_pix_fmt != PIX_FMT_YUV444P && |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2573 src_pix_fmt != PIX_FMT_YUVJ444P)) { |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2574 /* yuv444 is the normalized format */ |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2575 if (src_pix->color_type == FF_COLOR_YUV_JPEG) |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2576 int_pix_fmt = PIX_FMT_YUVJ444P; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2577 else |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2578 int_pix_fmt = PIX_FMT_YUV444P; |
2967 | 2579 } else if ((is_yuv_planar(dst_pix) && |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2580 dst_pix_fmt != PIX_FMT_YUV444P && |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2581 dst_pix_fmt != PIX_FMT_YUVJ444P)) { |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2582 /* yuv444 is the normalized format */ |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2583 if (dst_pix->color_type == FF_COLOR_YUV_JPEG) |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2584 int_pix_fmt = PIX_FMT_YUVJ444P; |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2585 else |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2586 int_pix_fmt = PIX_FMT_YUV444P; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2587 } else { |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2588 /* the two formats are rgb or gray8 or yuv[j]444p */ |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2589 if (src_pix->is_alpha && dst_pix->is_alpha) |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
2590 int_pix_fmt = PIX_FMT_RGB32; |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2591 else |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
2592 int_pix_fmt = PIX_FMT_RGB24; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2593 } |
6040
08e4fbdbf554
avoid infinite loop if pixel format conversion does not exist
bcoudurier
parents:
5963
diff
changeset
|
2594 if (src_pix_fmt == int_pix_fmt) |
08e4fbdbf554
avoid infinite loop if pixel format conversion does not exist
bcoudurier
parents:
5963
diff
changeset
|
2595 return -1; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2596 if (avpicture_alloc(tmp, int_pix_fmt, dst_width, dst_height) < 0) |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2597 return -1; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2598 ret = -1; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2599 if (img_convert(tmp, int_pix_fmt, |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2600 src, src_pix_fmt, src_width, src_height) < 0) |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2601 goto fail1; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2602 if (img_convert(dst, dst_pix_fmt, |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2603 tmp, int_pix_fmt, dst_width, dst_height) < 0) |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2604 goto fail1; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2605 ret = 0; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2606 fail1: |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2607 avpicture_free(tmp); |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
2608 return ret; |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2609 } |
3558 | 2610 #endif |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2611 |
1208 | 2612 /* 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
|
2613 static int get_alpha_info_pal8(const AVPicture *src, int width, int height) |
1208 | 2614 { |
2615 const unsigned char *p; | |
2616 int src_wrap, ret, x, y; | |
2617 unsigned int a; | |
2618 uint32_t *palette = (uint32_t *)src->data[1]; | |
2967 | 2619 |
1208 | 2620 p = src->data[0]; |
2621 src_wrap = src->linesize[0] - width; | |
2622 ret = 0; | |
2623 for(y=0;y<height;y++) { | |
2624 for(x=0;x<width;x++) { | |
2625 a = palette[p[0]] >> 24; | |
2626 if (a == 0x00) { | |
2627 ret |= FF_ALPHA_TRANSP; | |
2628 } else if (a != 0xff) { | |
2629 ret |= FF_ALPHA_SEMI_TRANSP; | |
2630 } | |
2631 p++; | |
2632 } | |
2633 p += src_wrap; | |
2634 } | |
2635 return ret; | |
2636 } | |
2637 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
2638 int img_get_alpha_info(const AVPicture *src, |
2979 | 2639 int pix_fmt, int width, int height) |
1208 | 2640 { |
3420 | 2641 const PixFmtInfo *pf = &pix_fmt_info[pix_fmt]; |
1208 | 2642 int ret; |
2643 | |
2644 pf = &pix_fmt_info[pix_fmt]; | |
2645 /* no alpha can be represented in format */ | |
2646 if (!pf->is_alpha) | |
2647 return 0; | |
2648 switch(pix_fmt) { | |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
2649 case PIX_FMT_RGB32: |
4515 | 2650 ret = get_alpha_info_rgb32(src, width, height); |
1208 | 2651 break; |
2652 case PIX_FMT_PAL8: | |
2653 ret = get_alpha_info_pal8(src, width, height); | |
2654 break; | |
2655 default: | |
2656 /* we do not know, so everything is indicated */ | |
2657 ret = FF_ALPHA_TRANSP | FF_ALPHA_SEMI_TRANSP; | |
2658 break; | |
2659 } | |
2660 return ret; | |
2661 } | |
801 | 2662 |
2663 #ifdef HAVE_MMX | |
2664 #define DEINT_INPLACE_LINE_LUM \ | |
2665 movd_m2r(lum_m4[0],mm0);\ | |
2666 movd_m2r(lum_m3[0],mm1);\ | |
2667 movd_m2r(lum_m2[0],mm2);\ | |
2668 movd_m2r(lum_m1[0],mm3);\ | |
2669 movd_m2r(lum[0],mm4);\ | |
2670 punpcklbw_r2r(mm7,mm0);\ | |
2671 movd_r2m(mm2,lum_m4[0]);\ | |
2672 punpcklbw_r2r(mm7,mm1);\ | |
2673 punpcklbw_r2r(mm7,mm2);\ | |
2674 punpcklbw_r2r(mm7,mm3);\ | |
2675 punpcklbw_r2r(mm7,mm4);\ | |
2676 paddw_r2r(mm3,mm1);\ | |
2677 psllw_i2r(1,mm2);\ | |
2678 paddw_r2r(mm4,mm0);\ | |
2679 psllw_i2r(2,mm1);\ | |
2680 paddw_r2r(mm6,mm2);\ | |
2681 paddw_r2r(mm2,mm1);\ | |
2682 psubusw_r2r(mm0,mm1);\ | |
2683 psrlw_i2r(3,mm1);\ | |
2684 packuswb_r2r(mm7,mm1);\ | |
2685 movd_r2m(mm1,lum_m2[0]); | |
2686 | |
2687 #define DEINT_LINE_LUM \ | |
2688 movd_m2r(lum_m4[0],mm0);\ | |
2689 movd_m2r(lum_m3[0],mm1);\ | |
2690 movd_m2r(lum_m2[0],mm2);\ | |
2691 movd_m2r(lum_m1[0],mm3);\ | |
2692 movd_m2r(lum[0],mm4);\ | |
2693 punpcklbw_r2r(mm7,mm0);\ | |
2694 punpcklbw_r2r(mm7,mm1);\ | |
2695 punpcklbw_r2r(mm7,mm2);\ | |
2696 punpcklbw_r2r(mm7,mm3);\ | |
2697 punpcklbw_r2r(mm7,mm4);\ | |
2698 paddw_r2r(mm3,mm1);\ | |
2699 psllw_i2r(1,mm2);\ | |
2700 paddw_r2r(mm4,mm0);\ | |
2701 psllw_i2r(2,mm1);\ | |
2702 paddw_r2r(mm6,mm2);\ | |
2703 paddw_r2r(mm2,mm1);\ | |
2704 psubusw_r2r(mm0,mm1);\ | |
2705 psrlw_i2r(3,mm1);\ | |
2706 packuswb_r2r(mm7,mm1);\ | |
2707 movd_r2m(mm1,dst[0]); | |
2708 #endif | |
2709 | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2710 /* filter parameters: [-1 4 2 4 -1] // 8 */ |
2967 | 2711 static void deinterlace_line(uint8_t *dst, |
2979 | 2712 const uint8_t *lum_m4, const uint8_t *lum_m3, |
2713 const uint8_t *lum_m2, const uint8_t *lum_m1, | |
2714 const uint8_t *lum, | |
2715 int size) | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2716 { |
801 | 2717 #ifndef HAVE_MMX |
4176 | 2718 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
|
2719 int sum; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2720 |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2721 for(;size > 0;size--) { |
801 | 2722 sum = -lum_m4[0]; |
2723 sum += lum_m3[0] << 2; | |
2724 sum += lum_m2[0] << 1; | |
2725 sum += lum_m1[0] << 2; | |
2726 sum += -lum[0]; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2727 dst[0] = cm[(sum + 4) >> 3]; |
801 | 2728 lum_m4++; |
2729 lum_m3++; | |
2730 lum_m2++; | |
2731 lum_m1++; | |
2732 lum++; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2733 dst++; |
801 | 2734 } |
2735 #else | |
2736 | |
1044 | 2737 { |
2738 mmx_t rounder; | |
2739 rounder.uw[0]=4; | |
2740 rounder.uw[1]=4; | |
2741 rounder.uw[2]=4; | |
2742 rounder.uw[3]=4; | |
2743 pxor_r2r(mm7,mm7); | |
2744 movq_m2r(rounder,mm6); | |
2745 } | |
801 | 2746 for (;size > 3; size-=4) { |
2747 DEINT_LINE_LUM | |
2748 lum_m4+=4; | |
2749 lum_m3+=4; | |
2750 lum_m2+=4; | |
2751 lum_m1+=4; | |
2752 lum+=4; | |
2753 dst+=4; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2754 } |
801 | 2755 #endif |
2756 } | |
1064 | 2757 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 | 2758 int size) |
2759 { | |
2760 #ifndef HAVE_MMX | |
4176 | 2761 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
801 | 2762 int sum; |
2763 | |
2764 for(;size > 0;size--) { | |
2765 sum = -lum_m4[0]; | |
2766 sum += lum_m3[0] << 2; | |
2767 sum += lum_m2[0] << 1; | |
2768 lum_m4[0]=lum_m2[0]; | |
2769 sum += lum_m1[0] << 2; | |
2770 sum += -lum[0]; | |
2771 lum_m2[0] = cm[(sum + 4) >> 3]; | |
2772 lum_m4++; | |
2773 lum_m3++; | |
2774 lum_m2++; | |
2775 lum_m1++; | |
2776 lum++; | |
2777 } | |
2778 #else | |
2779 | |
1044 | 2780 { |
2781 mmx_t rounder; | |
2782 rounder.uw[0]=4; | |
2783 rounder.uw[1]=4; | |
2784 rounder.uw[2]=4; | |
2785 rounder.uw[3]=4; | |
2786 pxor_r2r(mm7,mm7); | |
2787 movq_m2r(rounder,mm6); | |
2788 } | |
801 | 2789 for (;size > 3; size-=4) { |
2790 DEINT_INPLACE_LINE_LUM | |
2791 lum_m4+=4; | |
2792 lum_m3+=4; | |
2793 lum_m2+=4; | |
2794 lum_m1+=4; | |
2795 lum+=4; | |
2796 } | |
2797 #endif | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2798 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2799 |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2800 /* 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
|
2801 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
|
2802 against the top field. */ |
1064 | 2803 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
|
2804 const uint8_t *src1, int src_wrap, |
801 | 2805 int width, int height) |
2806 { | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
2807 const uint8_t *src_m2, *src_m1, *src_0, *src_p1, *src_p2; |
801 | 2808 int y; |
2809 | |
2810 src_m2 = src1; | |
2811 src_m1 = src1; | |
2812 src_0=&src_m1[src_wrap]; | |
2813 src_p1=&src_0[src_wrap]; | |
2814 src_p2=&src_p1[src_wrap]; | |
2815 for(y=0;y<(height-2);y+=2) { | |
2816 memcpy(dst,src_m1,width); | |
2817 dst += dst_wrap; | |
2818 deinterlace_line(dst,src_m2,src_m1,src_0,src_p1,src_p2,width); | |
2819 src_m2 = src_0; | |
2820 src_m1 = src_p1; | |
2821 src_0 = src_p2; | |
2822 src_p1 += 2*src_wrap; | |
2823 src_p2 += 2*src_wrap; | |
2824 dst += dst_wrap; | |
2825 } | |
2826 memcpy(dst,src_m1,width); | |
2827 dst += dst_wrap; | |
2828 /* do last line */ | |
2829 deinterlace_line(dst,src_m2,src_m1,src_0,src_0,src_0,width); | |
2830 } | |
2831 | |
1064 | 2832 static void deinterlace_bottom_field_inplace(uint8_t *src1, int src_wrap, |
2979 | 2833 int width, int height) |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2834 { |
1064 | 2835 uint8_t *src_m1, *src_0, *src_p1, *src_p2; |
801 | 2836 int y; |
1064 | 2837 uint8_t *buf; |
2838 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
|
2839 |
801 | 2840 src_m1 = src1; |
2841 memcpy(buf,src_m1,width); | |
2842 src_0=&src_m1[src_wrap]; | |
2843 src_p1=&src_0[src_wrap]; | |
2844 src_p2=&src_p1[src_wrap]; | |
2845 for(y=0;y<(height-2);y+=2) { | |
2846 deinterlace_line_inplace(buf,src_m1,src_0,src_p1,src_p2,width); | |
2847 src_m1 = src_p1; | |
2848 src_0 = src_p2; | |
2849 src_p1 += 2*src_wrap; | |
2850 src_p2 += 2*src_wrap; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2851 } |
801 | 2852 /* do last line */ |
2853 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
|
2854 av_free(buf); |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2855 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2856 |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
2857 int avpicture_deinterlace(AVPicture *dst, const AVPicture *src, |
0 | 2858 int pix_fmt, int width, int height) |
2859 { | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2860 int i; |
0 | 2861 |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2862 if (pix_fmt != PIX_FMT_YUV420P && |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2863 pix_fmt != PIX_FMT_YUV422P && |
1425
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
2864 pix_fmt != PIX_FMT_YUV444P && |
5810 | 2865 pix_fmt != PIX_FMT_YUV411P && |
2866 pix_fmt != PIX_FMT_GRAY8) | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2867 return -1; |
801 | 2868 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
|
2869 return -1; |
801 | 2870 |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2871 for(i=0;i<3;i++) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2872 if (i == 1) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2873 switch(pix_fmt) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2874 case PIX_FMT_YUV420P: |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2875 width >>= 1; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2876 height >>= 1; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2877 break; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2878 case PIX_FMT_YUV422P: |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2879 width >>= 1; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2880 break; |
1425
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
2881 case PIX_FMT_YUV411P: |
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
2882 width >>= 2; |
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
2883 break; |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2884 default: |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2885 break; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2886 } |
5810 | 2887 if (pix_fmt == PIX_FMT_GRAY8) { |
2888 break; | |
2889 } | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2890 } |
801 | 2891 if (src == dst) { |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
2892 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
|
2893 width, height); |
801 | 2894 } else { |
2895 deinterlace_bottom_field(dst->data[i],dst->linesize[i], | |
2896 src->data[i], src->linesize[i], | |
2897 width, height); | |
2898 } | |
0 | 2899 } |
5735 | 2900 emms_c(); |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
2901 return 0; |
0 | 2902 } |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
2903 |