Mercurial > libavcodec.hg
annotate imgconvert.c @ 10577:db54dba1f21c libavcodec
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
av_pix_fmt_descriptors log2_chroma_w and log2_chroma_h values instead.
author | stefano |
---|---|
date | Thu, 26 Nov 2009 20:00:03 +0000 |
parents | ac49ab818d4d |
children | dacdec913c5b |
rev | line source |
---|---|
0 | 1 /* |
5355 | 2 * Misc image conversion routines |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8601
diff
changeset
|
3 * Copyright (c) 2001, 2002, 2003 Fabrice Bellard |
0 | 4 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3646
diff
changeset
|
5 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3646
diff
changeset
|
6 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3646
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
429 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3646
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
0 | 11 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3646
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
0 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 * Lesser General Public License for more details. | |
0 | 16 * |
429 | 17 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3646
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2979
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 20 */ |
1106 | 21 |
22 /** | |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
8631
diff
changeset
|
23 * @file libavcodec/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" |
10572
a21b640dba50
Use av_pix_fmt_descriptors in ff_is_hwaccel_pix_fmt() rather than
stefano
parents:
10569
diff
changeset
|
36 #include "libavutil/pixdesc.h" |
0 | 37 |
8590 | 38 #if HAVE_MMX |
8430 | 39 #include "x86/mmx.h" |
40 #include "x86/dsputil_mmx.h" | |
801 | 41 #endif |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
42 |
1204 | 43 #define xglue(x, y) x ## y |
44 #define glue(x, y) xglue(x, y) | |
45 | |
4549 | 46 #define FF_COLOR_RGB 0 /**< RGB color space */ |
47 #define FF_COLOR_GRAY 1 /**< gray color space */ | |
48 #define FF_COLOR_YUV 2 /**< YUV color space. 16 <= Y <= 235, 16 <= U, V <= 240 */ | |
49 #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
|
50 |
4549 | 51 #define FF_PIXEL_PLANAR 0 /**< each channel has one component in AVPicture */ |
52 #define FF_PIXEL_PACKED 1 /**< only one components containing all the channels */ | |
53 #define FF_PIXEL_PALETTE 2 /**< one components containing indexes for a palette */ | |
1204 | 54 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
55 typedef struct PixFmtInfo { |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
56 const char *name; |
4549 | 57 uint8_t nb_channels; /**< number of channels (including alpha) */ |
58 uint8_t color_type; /**< color type (see FF_COLOR_xxx constants) */ | |
59 uint8_t pixel_type; /**< pixel storage type (see FF_PIXEL_xxx constants) */ | |
60 uint8_t is_alpha : 1; /**< true if alpha can be specified */ | |
9011
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
61 uint8_t is_hwaccel : 1; /**< true if this is an HW accelerated format */ |
4549 | 62 uint8_t depth; /**< bit depth of the color components */ |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
63 } PixFmtInfo; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
64 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
65 /* this table gives more information about formats */ |
3420 | 66 static const PixFmtInfo pix_fmt_info[PIX_FMT_NB] = { |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
67 /* YUV formats */ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
68 [PIX_FMT_YUV420P] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
69 .name = "yuv420p", |
1204 | 70 .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
|
71 .color_type = FF_COLOR_YUV, |
1204 | 72 .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
|
73 .depth = 8, |
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, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
81 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
82 [PIX_FMT_YUV444P] = { |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
993
diff
changeset
|
83 .name = "yuv444p", |
1204 | 84 .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
|
85 .color_type = FF_COLOR_YUV, |
1204 | 86 .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
|
87 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
88 }, |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
89 [PIX_FMT_YUYV422] = { |
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
90 .name = "yuyv422", |
1204 | 91 .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
|
92 .color_type = FF_COLOR_YUV, |
1204 | 93 .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
|
94 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
95 }, |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
96 [PIX_FMT_UYVY422] = { |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
97 .name = "uyvy422", |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
98 .nb_channels = 1, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
99 .color_type = FF_COLOR_YUV, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
100 .pixel_type = FF_PIXEL_PACKED, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
101 .depth = 8, |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
102 }, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
103 [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
|
104 .name = "yuv410p", |
1204 | 105 .nb_channels = 3, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
106 .color_type = FF_COLOR_YUV, |
1204 | 107 .pixel_type = FF_PIXEL_PLANAR, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
108 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
109 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
110 [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
|
111 .name = "yuv411p", |
1204 | 112 .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
|
113 .color_type = FF_COLOR_YUV, |
1204 | 114 .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
|
115 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
116 }, |
5363 | 117 [PIX_FMT_YUV440P] = { |
118 .name = "yuv440p", | |
119 .nb_channels = 3, | |
120 .color_type = FF_COLOR_YUV, | |
121 .pixel_type = FF_PIXEL_PLANAR, | |
122 .depth = 8, | |
123 }, | |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
124 [PIX_FMT_YUV420P16LE] = { |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
125 .name = "yuv420p16le", |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
126 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
127 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
128 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
129 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
130 }, |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
131 [PIX_FMT_YUV422P16LE] = { |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
132 .name = "yuv422p16le", |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
133 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
134 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
135 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
136 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
137 }, |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
138 [PIX_FMT_YUV444P16LE] = { |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
139 .name = "yuv444p16le", |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
140 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
141 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
142 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
143 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
144 }, |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
145 [PIX_FMT_YUV420P16BE] = { |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
146 .name = "yuv420p16be", |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
147 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
148 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
149 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
150 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
151 }, |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
152 [PIX_FMT_YUV422P16BE] = { |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
153 .name = "yuv422p16be", |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
154 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
155 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
156 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
157 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
158 }, |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
159 [PIX_FMT_YUV444P16BE] = { |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
160 .name = "yuv444p16be", |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
161 .nb_channels = 3, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
162 .color_type = FF_COLOR_YUV, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
163 .pixel_type = FF_PIXEL_PLANAR, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
164 .depth = 16, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
165 }, |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
166 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
167 |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
168 /* YUV formats with alpha plane */ |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
169 [PIX_FMT_YUVA420P] = { |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
170 .name = "yuva420p", |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
171 .nb_channels = 4, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
172 .color_type = FF_COLOR_YUV, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
173 .pixel_type = FF_PIXEL_PLANAR, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
174 .depth = 8, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
175 }, |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
176 |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
177 /* JPEG YUV */ |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
178 [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
|
179 .name = "yuvj420p", |
1204 | 180 .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
|
181 .color_type = FF_COLOR_YUV_JPEG, |
1204 | 182 .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
|
183 .depth = 8, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
184 }, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
185 [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
|
186 .name = "yuvj422p", |
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_YUV_JPEG, |
1204 | 189 .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
|
190 .depth = 8, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
191 }, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
192 [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
|
193 .name = "yuvj444p", |
1204 | 194 .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
|
195 .color_type = FF_COLOR_YUV_JPEG, |
1204 | 196 .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
|
197 .depth = 8, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
198 }, |
5363 | 199 [PIX_FMT_YUVJ440P] = { |
200 .name = "yuvj440p", | |
201 .nb_channels = 3, | |
202 .color_type = FF_COLOR_YUV_JPEG, | |
203 .pixel_type = FF_PIXEL_PLANAR, | |
204 .depth = 8, | |
205 }, | |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
206 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
207 /* RGB formats */ |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
208 [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
|
209 .name = "rgb24", |
1204 | 210 .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
|
211 .color_type = FF_COLOR_RGB, |
1204 | 212 .pixel_type = FF_PIXEL_PACKED, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
213 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
214 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
215 [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
|
216 .name = "bgr24", |
1204 | 217 .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
|
218 .color_type = FF_COLOR_RGB, |
1204 | 219 .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
|
220 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
221 }, |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
222 [PIX_FMT_ARGB] = { |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
223 .name = "argb", |
1204 | 224 .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
|
225 .color_type = FF_COLOR_RGB, |
1204 | 226 .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
|
227 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
228 }, |
9001 | 229 [PIX_FMT_RGB48BE] = { |
230 .name = "rgb48be", | |
231 .nb_channels = 3, | |
232 .color_type = FF_COLOR_RGB, | |
233 .pixel_type = FF_PIXEL_PACKED, | |
234 .depth = 16, | |
235 }, | |
236 [PIX_FMT_RGB48LE] = { | |
237 .name = "rgb48le", | |
238 .nb_channels = 3, | |
239 .color_type = FF_COLOR_RGB, | |
240 .pixel_type = FF_PIXEL_PACKED, | |
241 .depth = 16, | |
242 }, | |
9223
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
243 [PIX_FMT_RGB565BE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
244 .name = "rgb565be", |
1204 | 245 .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
|
246 .color_type = FF_COLOR_RGB, |
1204 | 247 .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
|
248 .depth = 5, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
249 }, |
9223
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
250 [PIX_FMT_RGB565LE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
251 .name = "rgb565le", |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
252 .nb_channels = 3, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
253 .color_type = FF_COLOR_RGB, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
254 .pixel_type = FF_PIXEL_PACKED, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
255 .depth = 5, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
256 }, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
257 [PIX_FMT_RGB555BE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
258 .name = "rgb555be", |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
259 .nb_channels = 3, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
260 .color_type = FF_COLOR_RGB, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
261 .pixel_type = FF_PIXEL_PACKED, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
262 .depth = 5, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
263 }, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
264 [PIX_FMT_RGB555LE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
265 .name = "rgb555le", |
4208 | 266 .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
|
267 .color_type = FF_COLOR_RGB, |
1204 | 268 .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
|
269 .depth = 5, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
270 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
271 |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
272 /* gray / mono formats */ |
4066 | 273 [PIX_FMT_GRAY16BE] = { |
274 .name = "gray16be", | |
275 .nb_channels = 1, | |
276 .color_type = FF_COLOR_GRAY, | |
277 .pixel_type = FF_PIXEL_PLANAR, | |
278 .depth = 16, | |
279 }, | |
280 [PIX_FMT_GRAY16LE] = { | |
281 .name = "gray16le", | |
282 .nb_channels = 1, | |
283 .color_type = FF_COLOR_GRAY, | |
284 .pixel_type = FF_PIXEL_PLANAR, | |
285 .depth = 16, | |
286 }, | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
287 [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
|
288 .name = "gray", |
1204 | 289 .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
|
290 .color_type = FF_COLOR_GRAY, |
1204 | 291 .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
|
292 .depth = 8, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
293 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
294 [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
|
295 .name = "monow", |
1204 | 296 .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
|
297 .color_type = FF_COLOR_GRAY, |
1204 | 298 .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
|
299 .depth = 1, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
300 }, |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
301 [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
|
302 .name = "monob", |
1204 | 303 .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
|
304 .color_type = FF_COLOR_GRAY, |
1204 | 305 .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
|
306 .depth = 1, |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
307 }, |
1055 | 308 |
309 /* paletted formats */ | |
310 [PIX_FMT_PAL8] = { | |
311 .name = "pal8", | |
1204 | 312 .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
|
313 .color_type = FF_COLOR_RGB, |
1204 | 314 .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
|
315 .depth = 8, |
1055 | 316 }, |
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
|
317 [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
|
318 .name = "xvmcmc", |
9011
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
319 .is_hwaccel = 1, |
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
|
320 }, |
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
|
321 [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
|
322 .name = "xvmcidct", |
9011
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
323 .is_hwaccel = 1, |
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
|
324 }, |
8601
8b80f8285b1b
Add VDPAU hardware accelerated decoding for MPEG1 and MPEG2 which can
cehoyos
parents:
8590
diff
changeset
|
325 [PIX_FMT_VDPAU_MPEG1] = { |
8b80f8285b1b
Add VDPAU hardware accelerated decoding for MPEG1 and MPEG2 which can
cehoyos
parents:
8590
diff
changeset
|
326 .name = "vdpau_mpeg1", |
9011
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
327 .is_hwaccel = 1, |
8601
8b80f8285b1b
Add VDPAU hardware accelerated decoding for MPEG1 and MPEG2 which can
cehoyos
parents:
8590
diff
changeset
|
328 }, |
8b80f8285b1b
Add VDPAU hardware accelerated decoding for MPEG1 and MPEG2 which can
cehoyos
parents:
8590
diff
changeset
|
329 [PIX_FMT_VDPAU_MPEG2] = { |
8b80f8285b1b
Add VDPAU hardware accelerated decoding for MPEG1 and MPEG2 which can
cehoyos
parents:
8590
diff
changeset
|
330 .name = "vdpau_mpeg2", |
9011
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
331 .is_hwaccel = 1, |
8601
8b80f8285b1b
Add VDPAU hardware accelerated decoding for MPEG1 and MPEG2 which can
cehoyos
parents:
8590
diff
changeset
|
332 }, |
8522
f8c091bb5779
Add VDPAU hardware accelerated decoding for H264 which can be used by
cehoyos
parents:
8430
diff
changeset
|
333 [PIX_FMT_VDPAU_H264] = { |
f8c091bb5779
Add VDPAU hardware accelerated decoding for H264 which can be used by
cehoyos
parents:
8430
diff
changeset
|
334 .name = "vdpau_h264", |
9011
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
335 .is_hwaccel = 1, |
8522
f8c091bb5779
Add VDPAU hardware accelerated decoding for H264 which can be used by
cehoyos
parents:
8430
diff
changeset
|
336 }, |
8631
2d7269e13a8d
Add VDPAU hardware accelerated decoding for WMV3 and VC1 which can
cehoyos
parents:
8629
diff
changeset
|
337 [PIX_FMT_VDPAU_WMV3] = { |
2d7269e13a8d
Add VDPAU hardware accelerated decoding for WMV3 and VC1 which can
cehoyos
parents:
8629
diff
changeset
|
338 .name = "vdpau_wmv3", |
9011
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
339 .is_hwaccel = 1, |
8631
2d7269e13a8d
Add VDPAU hardware accelerated decoding for WMV3 and VC1 which can
cehoyos
parents:
8629
diff
changeset
|
340 }, |
2d7269e13a8d
Add VDPAU hardware accelerated decoding for WMV3 and VC1 which can
cehoyos
parents:
8629
diff
changeset
|
341 [PIX_FMT_VDPAU_VC1] = { |
2d7269e13a8d
Add VDPAU hardware accelerated decoding for WMV3 and VC1 which can
cehoyos
parents:
8629
diff
changeset
|
342 .name = "vdpau_vc1", |
9011
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
343 .is_hwaccel = 1, |
8631
2d7269e13a8d
Add VDPAU hardware accelerated decoding for WMV3 and VC1 which can
cehoyos
parents:
8629
diff
changeset
|
344 }, |
10509
cdf5b1ed3500
Add VDPAU hardware accelerated decoding for MPEG-4 ASP which can be used
cehoyos
parents:
10383
diff
changeset
|
345 [PIX_FMT_VDPAU_MPEG4] = { |
cdf5b1ed3500
Add VDPAU hardware accelerated decoding for MPEG-4 ASP which can be used
cehoyos
parents:
10383
diff
changeset
|
346 .name = "vdpau_mpeg4", |
cdf5b1ed3500
Add VDPAU hardware accelerated decoding for MPEG-4 ASP which can be used
cehoyos
parents:
10383
diff
changeset
|
347 .is_hwaccel = 1, |
cdf5b1ed3500
Add VDPAU hardware accelerated decoding for MPEG-4 ASP which can be used
cehoyos
parents:
10383
diff
changeset
|
348 }, |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
349 [PIX_FMT_UYYVYY411] = { |
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
350 .name = "uyyvyy411", |
2309 | 351 .nb_channels = 1, |
352 .color_type = FF_COLOR_YUV, | |
353 .pixel_type = FF_PIXEL_PACKED, | |
354 .depth = 8, | |
355 }, | |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
356 [PIX_FMT_ABGR] = { |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
357 .name = "abgr", |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
358 .nb_channels = 4, .is_alpha = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
359 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
360 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
361 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
362 }, |
9223
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
363 [PIX_FMT_BGR565BE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
364 .name = "bgr565be", |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
365 .nb_channels = 3, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
366 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
367 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
368 .depth = 5, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
369 }, |
9223
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
370 [PIX_FMT_BGR565LE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
371 .name = "bgr565le", |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
372 .nb_channels = 3, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
373 .color_type = FF_COLOR_RGB, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
374 .pixel_type = FF_PIXEL_PACKED, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
375 .depth = 5, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
376 }, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
377 [PIX_FMT_BGR555BE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
378 .name = "bgr555be", |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
379 .nb_channels = 3, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
380 .color_type = FF_COLOR_RGB, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
381 .pixel_type = FF_PIXEL_PACKED, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
382 .depth = 5, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
383 }, |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
384 [PIX_FMT_BGR555LE] = { |
53f2c0f6e71d
Change the RGB5X5/BGR5X5 pixel format defines so that we have little
stefano
parents:
9222
diff
changeset
|
385 .name = "bgr555le", |
4207
bc9de4875ebd
BGR555 has never been working as alpha supporting format. Remove the false setting.
alex
parents:
4201
diff
changeset
|
386 .nb_channels = 3, |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
387 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
388 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
389 .depth = 5, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
390 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
391 [PIX_FMT_RGB8] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
392 .name = "rgb8", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
393 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
394 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
395 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
396 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
397 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
398 [PIX_FMT_RGB4] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
399 .name = "rgb4", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
400 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
401 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
402 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
403 .depth = 4, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
404 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
405 [PIX_FMT_RGB4_BYTE] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
406 .name = "rgb4_byte", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
407 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
408 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
409 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
410 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
411 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
412 [PIX_FMT_BGR8] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
413 .name = "bgr8", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
414 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
415 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
416 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
417 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
418 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
419 [PIX_FMT_BGR4] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
420 .name = "bgr4", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
421 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
422 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
423 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
424 .depth = 4, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
425 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
426 [PIX_FMT_BGR4_BYTE] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
427 .name = "bgr4_byte", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
428 .nb_channels = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
429 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
430 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
431 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
432 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
433 [PIX_FMT_NV12] = { |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
434 .name = "nv12", |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
435 .nb_channels = 2, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
436 .color_type = FF_COLOR_YUV, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
437 .pixel_type = FF_PIXEL_PLANAR, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
438 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
439 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
440 [PIX_FMT_NV21] = { |
10540 | 441 .name = "nv21", |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
442 .nb_channels = 2, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
443 .color_type = FF_COLOR_YUV, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
444 .pixel_type = FF_PIXEL_PLANAR, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
445 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
446 }, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
447 |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
448 [PIX_FMT_BGRA] = { |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
449 .name = "bgra", |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
450 .nb_channels = 4, .is_alpha = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
451 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
452 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
453 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
454 }, |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
455 [PIX_FMT_RGBA] = { |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
456 .name = "rgba", |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
457 .nb_channels = 4, .is_alpha = 1, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
458 .color_type = FF_COLOR_RGB, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
459 .pixel_type = FF_PIXEL_PACKED, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
460 .depth = 8, |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
461 }, |
9061 | 462 |
463 /* VA API formats */ | |
464 [PIX_FMT_VAAPI_MOCO] = { | |
465 .name = "vaapi_moco", | |
466 .is_hwaccel = 1, | |
467 }, | |
468 [PIX_FMT_VAAPI_IDCT] = { | |
469 .name = "vaapi_idct", | |
470 .is_hwaccel = 1, | |
471 }, | |
472 [PIX_FMT_VAAPI_VLD] = { | |
473 .name = "vaapi_vld", | |
474 .is_hwaccel = 1, | |
475 }, | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
476 }; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
477 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
478 void avcodec_get_chroma_sub_sample(enum PixelFormat pix_fmt, int *h_shift, int *v_shift) |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
479 { |
10573
ac49ab818d4d
Use av_pix_fmt_descriptors in avcodec_get_chroma_sub_sample(), rather
stefano
parents:
10572
diff
changeset
|
480 *h_shift = av_pix_fmt_descriptors[pix_fmt].log2_chroma_w; |
ac49ab818d4d
Use av_pix_fmt_descriptors in avcodec_get_chroma_sub_sample(), rather
stefano
parents:
10572
diff
changeset
|
481 *v_shift = av_pix_fmt_descriptors[pix_fmt].log2_chroma_h; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
482 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
483 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
484 const char *avcodec_get_pix_fmt_name(enum PixelFormat pix_fmt) |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
485 { |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
486 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
|
487 return NULL; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
488 else |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
489 return pix_fmt_info[pix_fmt].name; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
490 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
491 |
9222
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
492 static enum PixelFormat avcodec_get_pix_fmt_internal(const char *name) |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
493 { |
2967 | 494 int i; |
495 | |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
496 for (i=0; i < PIX_FMT_NB; i++) |
9434 | 497 if (pix_fmt_info[i].name && !strcmp(pix_fmt_info[i].name, name)) |
9435 | 498 return i; |
7463
5515e19b9137
Add graceful error handling to avcodec_get_pix_fmt_name() and avcodec_get_pix_fmt().
pross
parents:
6963
diff
changeset
|
499 return PIX_FMT_NONE; |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
500 } |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
501 |
9985 | 502 #if HAVE_BIGENDIAN |
9240 | 503 # define X_NE(be, le) be |
504 #else | |
505 # define X_NE(be, le) le | |
506 #endif | |
507 | |
9222
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
508 enum PixelFormat avcodec_get_pix_fmt(const char *name) |
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
509 { |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
510 enum PixelFormat pix_fmt; |
9222
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
511 |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
512 if (!strcmp(name, "rgb32")) |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
513 name = X_NE("argb", "bgra"); |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
514 else if (!strcmp(name, "bgr32")) |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
515 name = X_NE("abgr", "rgba"); |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
516 |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
517 pix_fmt = avcodec_get_pix_fmt_internal(name); |
9222
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
518 if (pix_fmt == PIX_FMT_NONE) { |
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
519 char name2[32]; |
9242
3153dcc9f8d0
Factorize: use the X_NE() macro in avcodec_get_pix_fmt().
stefano
parents:
9240
diff
changeset
|
520 snprintf(name2, sizeof(name2), "%s%s", name, X_NE("be", "le")); |
9222
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
521 pix_fmt = avcodec_get_pix_fmt_internal(name2); |
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
522 } |
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
523 return pix_fmt; |
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
524 } |
e314914641bc
Extend the behavior of avcodec_get_pix_fmt(), if it cannot find a
stefano
parents:
9221
diff
changeset
|
525 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
526 void avcodec_pix_fmt_string (char *buf, int buf_size, enum PixelFormat pix_fmt) |
5084
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
527 { |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
528 /* print header */ |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
529 if (pix_fmt < 0) |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
530 snprintf (buf, buf_size, |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
531 "name " " nb_channels" " depth" " is_alpha" |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
532 ); |
6911 | 533 else{ |
534 PixFmtInfo info= pix_fmt_info[pix_fmt]; | |
535 | |
536 char is_alpha_char= info.is_alpha ? 'y' : 'n'; | |
537 | |
5084
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
538 snprintf (buf, buf_size, |
10277 | 539 "%-11s %5d %9d %6c", |
5084
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
540 info.name, |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
541 info.nb_channels, |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
542 info.depth, |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
543 is_alpha_char |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
544 ); |
6911 | 545 } |
5084
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
546 } |
9930b7031cb2
Add support for listing the supported pixel formats using the option
benoit
parents:
5077
diff
changeset
|
547 |
9011
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
548 int ff_is_hwaccel_pix_fmt(enum PixelFormat pix_fmt) |
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
549 { |
10572
a21b640dba50
Use av_pix_fmt_descriptors in ff_is_hwaccel_pix_fmt() rather than
stefano
parents:
10569
diff
changeset
|
550 return av_pix_fmt_descriptors[pix_fmt].flags & PIX_FMT_HWACCEL; |
9011
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
551 } |
90c99bda19f5
Approved hunks for VAAPI / our new shiny hwaccel API
michael
parents:
9007
diff
changeset
|
552 |
8748
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
553 int ff_set_systematic_pal(uint32_t pal[256], enum PixelFormat pix_fmt){ |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
554 int i; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
555 |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
556 for(i=0; i<256; i++){ |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
557 int r,g,b; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
558 |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
559 switch(pix_fmt) { |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
560 case PIX_FMT_RGB8: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
561 r= (i>>5 )*36; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
562 g= ((i>>2)&7)*36; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
563 b= (i&3 )*85; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
564 break; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
565 case PIX_FMT_BGR8: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
566 b= (i>>6 )*85; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
567 g= ((i>>3)&7)*36; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
568 r= (i&7 )*36; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
569 break; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
570 case PIX_FMT_RGB4_BYTE: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
571 r= (i>>3 )*255; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
572 g= ((i>>1)&3)*85; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
573 b= (i&1 )*255; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
574 break; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
575 case PIX_FMT_BGR4_BYTE: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
576 b= (i>>3 )*255; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
577 g= ((i>>1)&3)*85; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
578 r= (i&1 )*255; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
579 break; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
580 case PIX_FMT_GRAY8: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
581 r=b=g= i; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
582 break; |
8788
5e9e735cd793
Add a default (error) for the switch in case of an unsupported PIX_FMT.
gpoirier
parents:
8748
diff
changeset
|
583 default: |
5e9e735cd793
Add a default (error) for the switch in case of an unsupported PIX_FMT.
gpoirier
parents:
8748
diff
changeset
|
584 return -1; |
8748
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
585 } |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
586 pal[i] = b + (g<<8) + (r<<16); |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
587 } |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
588 |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
589 return 0; |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
590 } |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
591 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
592 int ff_fill_linesize(AVPicture *picture, enum PixelFormat pix_fmt, int width) |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
593 { |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
594 int w2; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
595 const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt]; |
2967 | 596 |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
597 memset(picture->linesize, 0, sizeof(picture->linesize)); |
2422 | 598 |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
599 switch(pix_fmt) { |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
600 case PIX_FMT_YUV420P: |
1047
3f316a471019
handle odd image sizes when using subsampled chroma (useful for JPEG images)
bellard
parents:
1044
diff
changeset
|
601 case PIX_FMT_YUV422P: |
3f316a471019
handle odd image sizes when using subsampled chroma (useful for JPEG images)
bellard
parents:
1044
diff
changeset
|
602 case PIX_FMT_YUV444P: |
3f316a471019
handle odd image sizes when using subsampled chroma (useful for JPEG images)
bellard
parents:
1044
diff
changeset
|
603 case PIX_FMT_YUV410P: |
3f316a471019
handle odd image sizes when using subsampled chroma (useful for JPEG images)
bellard
parents:
1044
diff
changeset
|
604 case PIX_FMT_YUV411P: |
5363 | 605 case PIX_FMT_YUV440P: |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
606 case PIX_FMT_YUVJ420P: |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
607 case PIX_FMT_YUVJ422P: |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
608 case PIX_FMT_YUVJ444P: |
5363 | 609 case PIX_FMT_YUVJ440P: |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
610 w2 = (width + (1 << desc->log2_chroma_w) - 1) >> desc->log2_chroma_w; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
611 picture->linesize[0] = width; |
1047
3f316a471019
handle odd image sizes when using subsampled chroma (useful for JPEG images)
bellard
parents:
1044
diff
changeset
|
612 picture->linesize[1] = w2; |
3f316a471019
handle odd image sizes when using subsampled chroma (useful for JPEG images)
bellard
parents:
1044
diff
changeset
|
613 picture->linesize[2] = w2; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
614 break; |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
615 case PIX_FMT_YUV420P16LE: |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
616 case PIX_FMT_YUV422P16LE: |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
617 case PIX_FMT_YUV444P16LE: |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
618 case PIX_FMT_YUV420P16BE: |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
619 case PIX_FMT_YUV422P16BE: |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
620 case PIX_FMT_YUV444P16BE: |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
621 w2 = (width + (1 << desc->log2_chroma_w) - 1) >> desc->log2_chroma_w; |
9519
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
622 picture->linesize[0] = 2*width; |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
623 picture->linesize[1] = 2*w2; |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
624 picture->linesize[2] = 2*w2; |
d42979883bb1
Add 420,422 and 444 planar 16bit per component pix formats.
michael
parents:
9483
diff
changeset
|
625 break; |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
626 case PIX_FMT_YUVA420P: |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
627 w2 = (width + (1 << desc->log2_chroma_w) - 1) >> desc->log2_chroma_w; |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
628 picture->linesize[0] = width; |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
629 picture->linesize[1] = w2; |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
630 picture->linesize[2] = w2; |
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
631 picture->linesize[3] = width; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
632 break; |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
633 case PIX_FMT_NV12: |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
634 case PIX_FMT_NV21: |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
635 w2 = (width + (1 << desc->log2_chroma_w) - 1) >> desc->log2_chroma_w; |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
636 picture->linesize[0] = width; |
10569
7a8b35405591
Fix nv12/nv21 handling. linesize for plane 1 should account for both chroma
ramiro
parents:
10546
diff
changeset
|
637 picture->linesize[1] = 2 * w2; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
638 break; |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
639 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
|
640 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
|
641 picture->linesize[0] = width * 3; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
642 break; |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
643 case PIX_FMT_ARGB: |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
644 case PIX_FMT_ABGR: |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
645 case PIX_FMT_RGBA: |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
646 case PIX_FMT_BGRA: |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
647 picture->linesize[0] = width * 4; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
648 break; |
9001 | 649 case PIX_FMT_RGB48BE: |
650 case PIX_FMT_RGB48LE: | |
651 picture->linesize[0] = width * 6; | |
652 break; | |
4066 | 653 case PIX_FMT_GRAY16BE: |
654 case PIX_FMT_GRAY16LE: | |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
655 case PIX_FMT_BGR555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
656 case PIX_FMT_BGR555LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
657 case PIX_FMT_BGR565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
658 case PIX_FMT_BGR565LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
659 case PIX_FMT_RGB555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
660 case PIX_FMT_RGB555LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
661 case PIX_FMT_RGB565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
662 case PIX_FMT_RGB565LE: |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
663 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
|
664 picture->linesize[0] = width * 2; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
665 break; |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
666 case PIX_FMT_UYVY422: |
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
667 picture->linesize[0] = width * 2; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
668 break; |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
669 case PIX_FMT_UYYVYY411: |
2309 | 670 picture->linesize[0] = width + width/2; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
671 break; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
672 case PIX_FMT_RGB4: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
673 case PIX_FMT_BGR4: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
674 picture->linesize[0] = width / 2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
675 break; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
676 case PIX_FMT_MONOWHITE: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
677 case PIX_FMT_MONOBLACK: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
678 picture->linesize[0] = (width + 7) >> 3; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
679 break; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
680 case PIX_FMT_PAL8: |
8748
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
681 case PIX_FMT_RGB8: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
682 case PIX_FMT_BGR8: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
683 case PIX_FMT_RGB4_BYTE: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
684 case PIX_FMT_BGR4_BYTE: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
685 case PIX_FMT_GRAY8: |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
686 picture->linesize[0] = width; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
687 break; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
688 default: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
689 return -1; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
690 } |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
691 return 0; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
692 } |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
693 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
694 int ff_fill_pointer(AVPicture *picture, uint8_t *ptr, enum PixelFormat pix_fmt, |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
695 int height) |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
696 { |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
697 int size, h2, size2; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
698 const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt]; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
699 |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
700 size = picture->linesize[0] * height; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
701 switch(pix_fmt) { |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
702 case PIX_FMT_YUV420P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
703 case PIX_FMT_YUV422P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
704 case PIX_FMT_YUV444P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
705 case PIX_FMT_YUV410P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
706 case PIX_FMT_YUV411P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
707 case PIX_FMT_YUV440P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
708 case PIX_FMT_YUVJ420P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
709 case PIX_FMT_YUVJ422P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
710 case PIX_FMT_YUVJ444P: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
711 case PIX_FMT_YUVJ440P: |
10136
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
712 case PIX_FMT_YUV420P16LE: |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
713 case PIX_FMT_YUV422P16LE: |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
714 case PIX_FMT_YUV444P16LE: |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
715 case PIX_FMT_YUV420P16BE: |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
716 case PIX_FMT_YUV422P16BE: |
399b5d6b5439
Make 16bit YUV formats compatible with NE avcodec_get_pix_fmt().
ramiro
parents:
10043
diff
changeset
|
717 case PIX_FMT_YUV444P16BE: |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
718 h2 = (height + (1 << desc->log2_chroma_h) - 1) >> desc->log2_chroma_h; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
719 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
|
720 picture->data[0] = ptr; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
721 picture->data[1] = picture->data[0] + size; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
722 picture->data[2] = picture->data[1] + size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
723 picture->data[3] = NULL; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
724 return size + 2 * size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
725 case PIX_FMT_YUVA420P: |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
726 h2 = (height + (1 << desc->log2_chroma_h) - 1) >> desc->log2_chroma_h; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
727 size2 = picture->linesize[1] * h2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
728 picture->data[0] = ptr; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
729 picture->data[1] = picture->data[0] + size; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
730 picture->data[2] = picture->data[1] + size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
731 picture->data[3] = picture->data[1] + size2 + size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
732 return 2 * size + 2 * size2; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
733 case PIX_FMT_NV12: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
734 case PIX_FMT_NV21: |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
735 h2 = (height + (1 << desc->log2_chroma_h) - 1) >> desc->log2_chroma_h; |
10569
7a8b35405591
Fix nv12/nv21 handling. linesize for plane 1 should account for both chroma
ramiro
parents:
10546
diff
changeset
|
736 size2 = picture->linesize[1] * h2; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
737 picture->data[0] = ptr; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
738 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
|
739 picture->data[2] = NULL; |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
740 picture->data[3] = NULL; |
10569
7a8b35405591
Fix nv12/nv21 handling. linesize for plane 1 should account for both chroma
ramiro
parents:
10546
diff
changeset
|
741 return size + size2; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
742 case PIX_FMT_RGB24: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
743 case PIX_FMT_BGR24: |
9245
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
744 case PIX_FMT_ARGB: |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
745 case PIX_FMT_ABGR: |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
746 case PIX_FMT_RGBA: |
b5d1395879a0
Make the pixel formats which were defined as macros:
stefano
parents:
9242
diff
changeset
|
747 case PIX_FMT_BGRA: |
9001 | 748 case PIX_FMT_RGB48BE: |
749 case PIX_FMT_RGB48LE: | |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
750 case PIX_FMT_GRAY16BE: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
751 case PIX_FMT_GRAY16LE: |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
752 case PIX_FMT_BGR555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
753 case PIX_FMT_BGR555LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
754 case PIX_FMT_BGR565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
755 case PIX_FMT_BGR565LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
756 case PIX_FMT_RGB555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
757 case PIX_FMT_RGB555LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
758 case PIX_FMT_RGB565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
759 case PIX_FMT_RGB565LE: |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
760 case PIX_FMT_YUYV422: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
761 case PIX_FMT_UYVY422: |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
762 case PIX_FMT_UYYVYY411: |
3646
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
763 case PIX_FMT_RGB4: |
e324e5ce41a1
Minimal support for the new pixel formats in libavcodec
lucabe
parents:
3589
diff
changeset
|
764 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
|
765 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
|
766 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
|
767 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
|
768 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
|
769 picture->data[2] = NULL; |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
770 picture->data[3] = NULL; |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
771 return size; |
1055 | 772 case PIX_FMT_PAL8: |
8748
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
773 case PIX_FMT_RGB8: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
774 case PIX_FMT_BGR8: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
775 case PIX_FMT_RGB4_BYTE: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
776 case PIX_FMT_BGR4_BYTE: |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
777 case PIX_FMT_GRAY8: |
1055 | 778 size2 = (size + 3) & ~3; |
779 picture->data[0] = ptr; | |
780 picture->data[1] = ptr + size2; /* palette is stored here as 256 32 bit words */ | |
781 picture->data[2] = NULL; | |
5706
3e8764a25c53
add support for yuva420p colorspace (yuv420p + alpha)
aurel
parents:
5363
diff
changeset
|
782 picture->data[3] = NULL; |
1055 | 783 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
|
784 default: |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
785 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
|
786 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
|
787 picture->data[2] = NULL; |
1055 | 788 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
|
789 return -1; |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
790 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
791 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
792 |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
793 int avpicture_fill(AVPicture *picture, uint8_t *ptr, |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
794 enum PixelFormat pix_fmt, int width, int height) |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
795 { |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
796 |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
797 if(avcodec_check_dimensions(NULL, width, height)) |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
798 return -1; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
799 |
6357 | 800 if (ff_fill_linesize(picture, pix_fmt, width)) |
6356
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
801 return -1; |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
802 |
6357 | 803 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
|
804 } |
afa99894d8d9
Split avpicture_fill() in two functions. This will be
vitor
parents:
6350
diff
changeset
|
805 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
806 int avpicture_layout(const AVPicture* src, enum PixelFormat pix_fmt, int width, int height, |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
807 unsigned char *dest, int dest_size) |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
808 { |
3420 | 809 const PixFmtInfo* pf = &pix_fmt_info[pix_fmt]; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
810 const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt]; |
9070
87f496299f09
Fix avpicture_layout to not chroma shift the alpha plane when outputting YUVA420P
sdrik
parents:
9061
diff
changeset
|
811 int i, j, w, ow, h, oh, data_planes; |
2967 | 812 const unsigned char* s; |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
813 int size = avpicture_get_size(pix_fmt, width, height); |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
814 |
2422 | 815 if (size > dest_size || size < 0) |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
816 return -1; |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
817 |
1243
5d2376294fbf
* fixing a bug in avpicture_layout (PAL8 wasn't handled properly)
romansh
parents:
1231
diff
changeset
|
818 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
|
819 if (pix_fmt == PIX_FMT_YUYV422 || |
2967 | 820 pix_fmt == PIX_FMT_UYVY422 || |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
821 pix_fmt == PIX_FMT_BGR565BE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
822 pix_fmt == PIX_FMT_BGR565LE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
823 pix_fmt == PIX_FMT_BGR555BE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
824 pix_fmt == PIX_FMT_BGR555LE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
825 pix_fmt == PIX_FMT_RGB565BE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
826 pix_fmt == PIX_FMT_RGB565LE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
827 pix_fmt == PIX_FMT_RGB555BE || |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
828 pix_fmt == PIX_FMT_RGB555LE) |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
829 w = width * 2; |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
830 else if (pix_fmt == PIX_FMT_UYYVYY411) |
10546 | 831 w = width + width/2; |
2979 | 832 else if (pix_fmt == PIX_FMT_PAL8) |
10546 | 833 w = width; |
2979 | 834 else |
10546 | 835 w = width * (pf->depth * pf->nb_channels / 8); |
2967 | 836 |
2979 | 837 data_planes = 1; |
838 h = height; | |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
839 } else { |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
840 data_planes = pf->nb_channels; |
2979 | 841 w = (width*pf->depth + 7)/8; |
842 h = height; | |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
843 } |
2967 | 844 |
9070
87f496299f09
Fix avpicture_layout to not chroma shift the alpha plane when outputting YUVA420P
sdrik
parents:
9061
diff
changeset
|
845 ow = w; |
87f496299f09
Fix avpicture_layout to not chroma shift the alpha plane when outputting YUVA420P
sdrik
parents:
9061
diff
changeset
|
846 oh = h; |
87f496299f09
Fix avpicture_layout to not chroma shift the alpha plane when outputting YUVA420P
sdrik
parents:
9061
diff
changeset
|
847 |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
848 for (i=0; i<data_planes; i++) { |
10546 | 849 if (i == 1) { |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
850 w = ((width >> desc->log2_chroma_w) * pf->depth + 7) / 8; |
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
851 h = height >> desc->log2_chroma_h; |
10569
7a8b35405591
Fix nv12/nv21 handling. linesize for plane 1 should account for both chroma
ramiro
parents:
10546
diff
changeset
|
852 if (pix_fmt == PIX_FMT_NV12 || pix_fmt == PIX_FMT_NV21) |
7a8b35405591
Fix nv12/nv21 handling. linesize for plane 1 should account for both chroma
ramiro
parents:
10546
diff
changeset
|
853 w <<= 1; |
10546 | 854 } else if (i == 3) { |
855 w = ow; | |
856 h = oh; | |
857 } | |
858 s = src->data[i]; | |
859 for(j=0; j<h; j++) { | |
860 memcpy(dest, s, w); | |
861 dest += w; | |
862 s += src->linesize[i]; | |
863 } | |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
864 } |
2967 | 865 |
1243
5d2376294fbf
* fixing a bug in avpicture_layout (PAL8 wasn't handled properly)
romansh
parents:
1231
diff
changeset
|
866 if (pf->pixel_type == FF_PIXEL_PALETTE) |
2979 | 867 memcpy((unsigned char *)(((size_t)dest + 3) & ~3), src->data[1], 256 * 4); |
2967 | 868 |
1231
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
869 return size; |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
870 } |
b88dfc4bbf8c
* introducing new public interface in imgconvert.c
romansh
parents:
1209
diff
changeset
|
871 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
872 int avpicture_get_size(enum PixelFormat pix_fmt, int width, int height) |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
873 { |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
874 AVPicture dummy_pict; |
9217
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
875 if(avcodec_check_dimensions(NULL, width, height)) |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
876 return -1; |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
877 switch (pix_fmt) { |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
878 case PIX_FMT_RGB8: |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
879 case PIX_FMT_BGR8: |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
880 case PIX_FMT_RGB4_BYTE: |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
881 case PIX_FMT_BGR4_BYTE: |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
882 case PIX_FMT_GRAY8: |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
883 // do not include palette for these pseudo-paletted formats |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
884 return width * height; |
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
885 } |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
886 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
|
887 } |
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
888 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
889 int avcodec_get_pix_fmt_loss(enum PixelFormat dst_pix_fmt, enum PixelFormat src_pix_fmt, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
890 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
|
891 { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
892 const PixFmtInfo *pf, *ps; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
893 const AVPixFmtDescriptor *src_desc = &av_pix_fmt_descriptors[src_pix_fmt]; |
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
894 const AVPixFmtDescriptor *dst_desc = &av_pix_fmt_descriptors[dst_pix_fmt]; |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
895 int loss; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
896 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
897 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
|
898 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
899 /* compute loss */ |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
900 loss = 0; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
901 pf = &pix_fmt_info[dst_pix_fmt]; |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
902 if (pf->depth < ps->depth || |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
903 ((dst_pix_fmt == PIX_FMT_RGB555BE || dst_pix_fmt == PIX_FMT_RGB555LE) && |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
904 (src_pix_fmt == PIX_FMT_RGB565BE || src_pix_fmt == PIX_FMT_RGB565LE))) |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
905 loss |= FF_LOSS_DEPTH; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
906 if (dst_desc->log2_chroma_w > src_desc->log2_chroma_w || |
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
907 dst_desc->log2_chroma_h > src_desc->log2_chroma_h) |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
908 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
|
909 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
|
910 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
|
911 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
|
912 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
|
913 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
|
914 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
915 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
|
916 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
|
917 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
|
918 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
919 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
|
920 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
|
921 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
|
922 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
923 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
|
924 if (ps->color_type != FF_COLOR_YUV_JPEG && |
2967 | 925 ps->color_type != FF_COLOR_YUV && |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
926 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
|
927 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
|
928 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
929 default: |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
930 /* 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
|
931 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
|
932 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
|
933 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
934 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
935 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
|
936 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
|
937 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
|
938 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
|
939 loss |= FF_LOSS_ALPHA; |
2967 | 940 if (pf->pixel_type == FF_PIXEL_PALETTE && |
1204 | 941 (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
|
942 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
|
943 return loss; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
944 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
945 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
946 static int avg_bits_per_pixel(enum PixelFormat pix_fmt) |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
947 { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
948 int bits; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
949 const PixFmtInfo *pf; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
950 const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt]; |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
951 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
952 pf = &pix_fmt_info[pix_fmt]; |
1204 | 953 switch(pf->pixel_type) { |
954 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
|
955 switch(pix_fmt) { |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
956 case PIX_FMT_YUYV422: |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
957 case PIX_FMT_UYVY422: |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
958 case PIX_FMT_RGB565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
959 case PIX_FMT_RGB565LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
960 case PIX_FMT_RGB555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
961 case PIX_FMT_RGB555LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
962 case PIX_FMT_BGR565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
963 case PIX_FMT_BGR565LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
964 case PIX_FMT_BGR555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
965 case PIX_FMT_BGR555LE: |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
966 bits = 16; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
967 break; |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
968 case PIX_FMT_UYYVYY411: |
2979 | 969 bits = 12; |
970 break; | |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
971 default: |
1204 | 972 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
|
973 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
974 } |
1204 | 975 break; |
976 case FF_PIXEL_PLANAR: | |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
977 if (desc->log2_chroma_w == 0 && desc->log2_chroma_h == 0) { |
1204 | 978 bits = pf->depth * pf->nb_channels; |
979 } else { | |
2967 | 980 bits = pf->depth + ((2 * pf->depth) >> |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
981 (desc->log2_chroma_w + desc->log2_chroma_h)); |
1204 | 982 } |
983 break; | |
984 case FF_PIXEL_PALETTE: | |
985 bits = 8; | |
986 break; | |
987 default: | |
988 bits = -1; | |
989 break; | |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
990 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
991 return bits; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
992 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
993 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
994 static enum PixelFormat avcodec_find_best_pix_fmt1(int64_t pix_fmt_mask, |
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
995 enum PixelFormat src_pix_fmt, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
996 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
|
997 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
|
998 { |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
999 int dist, i, loss, min_dist; |
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
1000 enum PixelFormat dst_pix_fmt; |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1001 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1002 /* 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
|
1003 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
|
1004 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
|
1005 for(i = 0;i < PIX_FMT_NB; i++) { |
8321
e9db9859de6c
Prevent shift overflow, patch by Anders Grnberg, galileo.m2 gmail com.
diego
parents:
8316
diff
changeset
|
1006 if (pix_fmt_mask & (1ULL << i)) { |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1007 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
|
1008 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
|
1009 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
|
1010 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
|
1011 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
|
1012 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
|
1013 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1014 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1015 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1016 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1017 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
|
1018 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1019 |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
1020 enum PixelFormat avcodec_find_best_pix_fmt(int64_t pix_fmt_mask, enum PixelFormat src_pix_fmt, |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1021 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
|
1022 { |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
1023 enum PixelFormat dst_pix_fmt; |
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
1024 int loss_mask, i; |
1202
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1025 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
|
1026 ~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
|
1027 ~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
|
1028 ~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
|
1029 ~(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
|
1030 ~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
|
1031 ~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
|
1032 0, |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1033 }; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1034 |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1035 /* 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
|
1036 i = 0; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1037 for(;;) { |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1038 loss_mask = loss_mask_order[i++]; |
2967 | 1039 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
|
1040 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
|
1041 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
|
1042 goto found; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1043 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
|
1044 break; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1045 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1046 return -1; |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1047 found: |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1048 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
|
1049 *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
|
1050 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
|
1051 } |
8b49a7ee4e4e
YUV formats/gray formats are correctly defined - added format loss information - preliminary JPEG YUV formats support
bellard
parents:
1199
diff
changeset
|
1052 |
3245 | 1053 void ff_img_copy_plane(uint8_t *dst, int dst_wrap, |
1205 | 1054 const uint8_t *src, int src_wrap, |
1055 int width, int height) | |
1204 | 1056 { |
2967 | 1057 if((!dst) || (!src)) |
2785 | 1058 return; |
1204 | 1059 for(;height > 0; height--) { |
1060 memcpy(dst, src, width); | |
1061 dst += dst_wrap; | |
1062 src += src_wrap; | |
1063 } | |
1064 } | |
1065 | |
6358 | 1066 int ff_get_plane_bytewidth(enum PixelFormat pix_fmt, int width, int plane) |
1204 | 1067 { |
6347 | 1068 int bits; |
3420 | 1069 const PixFmtInfo *pf = &pix_fmt_info[pix_fmt]; |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
1070 const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt]; |
2967 | 1071 |
1204 | 1072 pf = &pix_fmt_info[pix_fmt]; |
1073 switch(pf->pixel_type) { | |
1074 case FF_PIXEL_PACKED: | |
1075 switch(pix_fmt) { | |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1076 case PIX_FMT_YUYV422: |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
1593
diff
changeset
|
1077 case PIX_FMT_UYVY422: |
10043
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
1078 case PIX_FMT_RGB565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
1079 case PIX_FMT_RGB565LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
1080 case PIX_FMT_RGB555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
1081 case PIX_FMT_RGB555LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
1082 case PIX_FMT_BGR565BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
1083 case PIX_FMT_BGR565LE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
1084 case PIX_FMT_BGR555BE: |
5d5562aa94df
Use RGB5x5LE, RGB5x5BE, BGR5x5LE and BGR5x5BE instead of their native
cehoyos
parents:
9985
diff
changeset
|
1085 case PIX_FMT_BGR555LE: |
1204 | 1086 bits = 16; |
1087 break; | |
4494
ce643a22f049
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
4359
diff
changeset
|
1088 case PIX_FMT_UYYVYY411: |
2979 | 1089 bits = 12; |
1090 break; | |
1204 | 1091 default: |
1092 bits = pf->depth * pf->nb_channels; | |
1093 break; | |
1094 } | |
6347 | 1095 return (width * bits + 7) >> 3; |
1096 break; | |
1097 case FF_PIXEL_PLANAR: | |
1098 if (plane == 1 || plane == 2) | |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
1099 width= -((-width)>>desc->log2_chroma_w); |
6347 | 1100 |
1101 return (width * pf->depth + 7) >> 3; | |
1102 break; | |
1103 case FF_PIXEL_PALETTE: | |
1104 if (plane == 0) | |
1105 return width; | |
1204 | 1106 break; |
6347 | 1107 } |
1108 | |
1109 return -1; | |
1110 } | |
1111 | |
1112 void av_picture_copy(AVPicture *dst, const AVPicture *src, | |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
1113 enum PixelFormat pix_fmt, int width, int height) |
6347 | 1114 { |
1115 int i; | |
1116 const PixFmtInfo *pf = &pix_fmt_info[pix_fmt]; | |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
1117 const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt]; |
6347 | 1118 |
1119 switch(pf->pixel_type) { | |
1120 case FF_PIXEL_PACKED: | |
1204 | 1121 case FF_PIXEL_PLANAR: |
1122 for(i = 0; i < pf->nb_channels; i++) { | |
8087
661cd381d996
Remove unused variable, patch by Art Clarke, aclarke vlideshow com.
diego
parents:
8083
diff
changeset
|
1123 int h; |
6358 | 1124 int bwidth = ff_get_plane_bytewidth(pix_fmt, width, i); |
1204 | 1125 h = height; |
1126 if (i == 1 || i == 2) { | |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
1127 h= -((-height)>>desc->log2_chroma_h); |
1204 | 1128 } |
3245 | 1129 ff_img_copy_plane(dst->data[i], dst->linesize[i], |
1204 | 1130 src->data[i], src->linesize[i], |
1131 bwidth, h); | |
1132 } | |
1133 break; | |
1134 case FF_PIXEL_PALETTE: | |
3245 | 1135 ff_img_copy_plane(dst->data[0], dst->linesize[0], |
1204 | 1136 src->data[0], src->linesize[0], |
1137 width, height); | |
1138 /* copy the palette */ | |
10510
26fcf45bb486
Fix palette copying in av_picture_copy(). Previous code worked only if
vitor
parents:
10509
diff
changeset
|
1139 memcpy(dst->data[1], src->data[1], 4*256); |
1204 | 1140 break; |
1141 } | |
1142 } | |
993
895d3b01c6f4
added missing formats in all functions - added monoblack, monowhite and gray8 support for most conversions
bellard
parents:
989
diff
changeset
|
1143 |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1144 /* 2x2 -> 1x1 */ |
3245 | 1145 void ff_shrink22(uint8_t *dst, int dst_wrap, |
1205 | 1146 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
|
1147 int width, int height) |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1148 { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1149 int w; |
1205 | 1150 const uint8_t *s1, *s2; |
1151 uint8_t *d; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1152 |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1153 for(;height > 0; height--) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1154 s1 = src; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1155 s2 = s1 + src_wrap; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1156 d = dst; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1157 for(w = width;w >= 4; w-=4) { |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
1158 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
|
1159 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
|
1160 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
|
1161 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
|
1162 s1 += 8; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1163 s2 += 8; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1164 d += 4; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1165 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1166 for(;w > 0; w--) { |
1206
fd676abc754c
loss fixes (thanks to Daniel Serpell) - shrink22 fix
bellard
parents:
1205
diff
changeset
|
1167 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
|
1168 s1 += 2; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1169 s2 += 2; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1170 d++; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1171 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1172 src += 2 * src_wrap; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1173 dst += dst_wrap; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1174 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1175 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1176 |
1205 | 1177 /* 4x4 -> 1x1 */ |
3245 | 1178 void ff_shrink44(uint8_t *dst, int dst_wrap, |
1205 | 1179 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
|
1180 int width, int height) |
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1181 { |
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1182 int w; |
1205 | 1183 const uint8_t *s1, *s2, *s3, *s4; |
1184 uint8_t *d; | |
576
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1185 |
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1186 for(;height > 0; height--) { |
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1187 s1 = src; |
1205 | 1188 s2 = s1 + src_wrap; |
1189 s3 = s2 + src_wrap; | |
1190 s4 = s3 + src_wrap; | |
576
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1191 d = dst; |
1205 | 1192 for(w = width;w > 0; w--) { |
1193 d[0] = (s1[0] + s1[1] + s1[2] + s1[3] + | |
1194 s2[0] + s2[1] + s2[2] + s2[3] + | |
1195 s3[0] + s3[1] + s3[2] + s3[3] + | |
1196 s4[0] + s4[1] + s4[2] + s4[3] + 8) >> 4; | |
1197 s1 += 4; | |
1198 s2 += 4; | |
1199 s3 += 4; | |
1200 s4 += 4; | |
576
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1201 d++; |
9aa5f0d0124e
YUV410P to YUV420P patch by Franois Revol <revol at free dot fr>
michaelni
parents:
440
diff
changeset
|
1202 } |
1205 | 1203 src += 4 * src_wrap; |
1204 dst += dst_wrap; | |
1205 } | |
1206 } | |
1207 | |
3245 | 1208 /* 8x8 -> 1x1 */ |
1209 void ff_shrink88(uint8_t *dst, int dst_wrap, | |
1210 const uint8_t *src, int src_wrap, | |
1211 int width, int height) | |
1212 { | |
1213 int w, i; | |
1214 | |
1215 for(;height > 0; height--) { | |
1216 for(w = width;w > 0; w--) { | |
1217 int tmp=0; | |
1218 for(i=0; i<8; i++){ | |
1219 tmp += src[0] + src[1] + src[2] + src[3] + src[4] + src[5] + src[6] + src[7]; | |
1220 src += src_wrap; | |
1221 } | |
1222 *(dst++) = (tmp + 32)>>6; | |
1223 src += 8 - 8*src_wrap; | |
1224 } | |
1225 src += 8*src_wrap - 8*width; | |
1226 dst += dst_wrap - width; | |
1227 } | |
1228 } | |
1229 | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1230 |
1508 | 1231 int avpicture_alloc(AVPicture *picture, |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
1232 enum PixelFormat pix_fmt, int width, int height) |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1233 { |
3266
3b785e80ce3e
make "size" variable in avpicture_alloc signed, since avpicture_get_size
reimar
parents:
3257
diff
changeset
|
1234 int size; |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1235 void *ptr; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1236 |
9217
53ec03e7ba40
Fix avpicture_get_size for non-paletted formats with a helper palette
reimar
parents:
9191
diff
changeset
|
1237 size = avpicture_fill(picture, NULL, pix_fmt, width, height); |
2422 | 1238 if(size<0) |
1239 goto fail; | |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1240 ptr = av_malloc(size); |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1241 if (!ptr) |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1242 goto fail; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1243 avpicture_fill(picture, ptr, pix_fmt, width, height); |
8748
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
1244 if(picture->data[1] && !picture->data[2]) |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
1245 ff_set_systematic_pal((uint32_t*)picture->data[1], pix_fmt); |
eaa08ce79f9a
Ensure that the palette is set in data[1] for all 8bit formats.
michael
parents:
8718
diff
changeset
|
1246 |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1247 return 0; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1248 fail: |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1249 memset(picture, 0, sizeof(AVPicture)); |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1250 return -1; |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1251 } |
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1252 |
1508 | 1253 void avpicture_free(AVPicture *picture) |
989
fe9083c56733
simplified code (need automatic testing) - added primitive new format support.
bellard
parents:
940
diff
changeset
|
1254 { |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
1028
diff
changeset
|
1255 av_free(picture->data[0]); |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1256 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1257 |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1258 /* return true if yuv planar */ |
3420 | 1259 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
|
1260 { |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1261 return (ps->color_type == FF_COLOR_YUV || |
2967 | 1262 ps->color_type == FF_COLOR_YUV_JPEG) && |
1204 | 1263 ps->pixel_type == FF_PIXEL_PLANAR; |
1203
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1264 } |
80c73b9b0ba2
accurate YUV to RGB and RGB to YUV conversions - added comments
bellard
parents:
1202
diff
changeset
|
1265 |
4624
6a900f539e2c
Add the prefix "av_" to img_crop(), img_copy() and img_pad(), and rename "img"
takis
parents:
4593
diff
changeset
|
1266 int av_picture_crop(AVPicture *dst, const AVPicture *src, |
9902
9bdf9fe9018c
Fix argument type mismatches for av_picture_crop and av_picture_fill
mru
parents:
9519
diff
changeset
|
1267 enum PixelFormat pix_fmt, int top_band, int left_band) |
3179 | 1268 { |
1269 int y_shift; | |
1270 int x_shift; | |
1271 | |
1272 if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB || !is_yuv_planar(&pix_fmt_info[pix_fmt])) | |
1273 return -1; | |
1274 | |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
1275 y_shift = av_pix_fmt_descriptors[pix_fmt].log2_chroma_h; |
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
1276 x_shift = av_pix_fmt_descriptors[pix_fmt].log2_chroma_w; |
3179 | 1277 |
1278 dst->data[0] = src->data[0] + (top_band * src->linesize[0]) + left_band; | |
1279 dst->data[1] = src->data[1] + ((top_band >> y_shift) * src->linesize[1]) + (left_band >> x_shift); | |
1280 dst->data[2] = src->data[2] + ((top_band >> y_shift) * src->linesize[2]) + (left_band >> x_shift); | |
1281 | |
1282 dst->linesize[0] = src->linesize[0]; | |
1283 dst->linesize[1] = src->linesize[1]; | |
1284 dst->linesize[2] = src->linesize[2]; | |
1285 return 0; | |
1286 } | |
1287 | |
4624
6a900f539e2c
Add the prefix "av_" to img_crop(), img_copy() and img_pad(), and rename "img"
takis
parents:
4593
diff
changeset
|
1288 int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
1289 enum PixelFormat pix_fmt, int padtop, int padbottom, int padleft, int padright, |
4358 | 1290 int *color) |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1291 { |
4359
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1292 uint8_t *optr; |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1293 int y_shift; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1294 int x_shift; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1295 int yheight; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1296 int i, y; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1297 |
4358 | 1298 if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB || |
1299 !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
|
1300 |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1301 for (i = 0; i < 3; i++) { |
10577
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
1302 x_shift = i ? av_pix_fmt_descriptors[pix_fmt].log2_chroma_w : 0; |
db54dba1f21c
Remove x_chroma_shift and y_chroma_shift fields from PixFmtInfo, use
stefano
parents:
10573
diff
changeset
|
1303 y_shift = i ? av_pix_fmt_descriptors[pix_fmt].log2_chroma_h : 0; |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1304 |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1305 if (padtop || padleft) { |
4358 | 1306 memset(dst->data[i], color[i], |
1307 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
|
1308 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1309 |
4359
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1310 if (padleft || padright) { |
4358 | 1311 optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) + |
1312 (dst->linesize[i] - (padright >> x_shift)); | |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1313 yheight = (height - 1 - (padtop + padbottom)) >> y_shift; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1314 for (y = 0; y < yheight; y++) { |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1315 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
|
1316 optr += dst->linesize[i]; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1317 } |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1318 } |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1319 |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1320 if (src) { /* first line */ |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1321 uint8_t *iptr = src->data[i]; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1322 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
|
1323 (padleft >> x_shift); |
6963
cc2c5a21a0eb
memcpy considering output width, not src linesize, fix segv with av_picture_pad
bcoudurier
parents:
6911
diff
changeset
|
1324 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
|
1325 iptr += src->linesize[i]; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1326 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
|
1327 (dst->linesize[i] - (padright >> x_shift)); |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1328 yheight = (height - 1 - (padtop + padbottom)) >> y_shift; |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1329 for (y = 0; y < yheight; y++) { |
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1330 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
|
1331 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
|
1332 (width - padleft - padright) >> x_shift); |
4359
d276d6eed6a0
Avoid branches in the loop and solve a gcc warning
lu_zero
parents:
4358
diff
changeset
|
1333 iptr += src->linesize[i]; |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1334 optr += dst->linesize[i]; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1335 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1336 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1337 |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1338 if (padbottom || padright) { |
4358 | 1339 optr = dst->data[i] + dst->linesize[i] * |
1340 ((height - padbottom) >> y_shift) - (padright >> x_shift); | |
1341 memset(optr, color[i],dst->linesize[i] * | |
1342 (padbottom >> y_shift) + (padright >> x_shift)); | |
3257
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1343 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1344 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1345 return 0; |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1346 } |
63f61b09dcee
Baptiste COUDURIER's padding patch (reworked by me a little bit).
lucabe
parents:
3245
diff
changeset
|
1347 |
1208 | 1348 /* 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
|
1349 static int get_alpha_info_pal8(const AVPicture *src, int width, int height) |
1208 | 1350 { |
1351 const unsigned char *p; | |
1352 int src_wrap, ret, x, y; | |
1353 unsigned int a; | |
1354 uint32_t *palette = (uint32_t *)src->data[1]; | |
2967 | 1355 |
1208 | 1356 p = src->data[0]; |
1357 src_wrap = src->linesize[0] - width; | |
1358 ret = 0; | |
1359 for(y=0;y<height;y++) { | |
1360 for(x=0;x<width;x++) { | |
1361 a = palette[p[0]] >> 24; | |
1362 if (a == 0x00) { | |
1363 ret |= FF_ALPHA_TRANSP; | |
1364 } else if (a != 0xff) { | |
1365 ret |= FF_ALPHA_SEMI_TRANSP; | |
1366 } | |
1367 p++; | |
1368 } | |
1369 p += src_wrap; | |
1370 } | |
1371 return ret; | |
1372 } | |
1373 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1374 int img_get_alpha_info(const AVPicture *src, |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
1375 enum PixelFormat pix_fmt, int width, int height) |
1208 | 1376 { |
3420 | 1377 const PixFmtInfo *pf = &pix_fmt_info[pix_fmt]; |
1208 | 1378 int ret; |
1379 | |
1380 /* no alpha can be represented in format */ | |
1381 if (!pf->is_alpha) | |
1382 return 0; | |
1383 switch(pix_fmt) { | |
1384 case PIX_FMT_PAL8: | |
1385 ret = get_alpha_info_pal8(src, width, height); | |
1386 break; | |
1387 default: | |
1388 /* we do not know, so everything is indicated */ | |
1389 ret = FF_ALPHA_TRANSP | FF_ALPHA_SEMI_TRANSP; | |
1390 break; | |
1391 } | |
1392 return ret; | |
1393 } | |
801 | 1394 |
8590 | 1395 #if HAVE_MMX |
801 | 1396 #define DEINT_INPLACE_LINE_LUM \ |
1397 movd_m2r(lum_m4[0],mm0);\ | |
1398 movd_m2r(lum_m3[0],mm1);\ | |
1399 movd_m2r(lum_m2[0],mm2);\ | |
1400 movd_m2r(lum_m1[0],mm3);\ | |
1401 movd_m2r(lum[0],mm4);\ | |
1402 punpcklbw_r2r(mm7,mm0);\ | |
1403 movd_r2m(mm2,lum_m4[0]);\ | |
1404 punpcklbw_r2r(mm7,mm1);\ | |
1405 punpcklbw_r2r(mm7,mm2);\ | |
1406 punpcklbw_r2r(mm7,mm3);\ | |
1407 punpcklbw_r2r(mm7,mm4);\ | |
1408 paddw_r2r(mm3,mm1);\ | |
1409 psllw_i2r(1,mm2);\ | |
1410 paddw_r2r(mm4,mm0);\ | |
1411 psllw_i2r(2,mm1);\ | |
1412 paddw_r2r(mm6,mm2);\ | |
1413 paddw_r2r(mm2,mm1);\ | |
1414 psubusw_r2r(mm0,mm1);\ | |
1415 psrlw_i2r(3,mm1);\ | |
1416 packuswb_r2r(mm7,mm1);\ | |
1417 movd_r2m(mm1,lum_m2[0]); | |
1418 | |
1419 #define DEINT_LINE_LUM \ | |
1420 movd_m2r(lum_m4[0],mm0);\ | |
1421 movd_m2r(lum_m3[0],mm1);\ | |
1422 movd_m2r(lum_m2[0],mm2);\ | |
1423 movd_m2r(lum_m1[0],mm3);\ | |
1424 movd_m2r(lum[0],mm4);\ | |
1425 punpcklbw_r2r(mm7,mm0);\ | |
1426 punpcklbw_r2r(mm7,mm1);\ | |
1427 punpcklbw_r2r(mm7,mm2);\ | |
1428 punpcklbw_r2r(mm7,mm3);\ | |
1429 punpcklbw_r2r(mm7,mm4);\ | |
1430 paddw_r2r(mm3,mm1);\ | |
1431 psllw_i2r(1,mm2);\ | |
1432 paddw_r2r(mm4,mm0);\ | |
1433 psllw_i2r(2,mm1);\ | |
1434 paddw_r2r(mm6,mm2);\ | |
1435 paddw_r2r(mm2,mm1);\ | |
1436 psubusw_r2r(mm0,mm1);\ | |
1437 psrlw_i2r(3,mm1);\ | |
1438 packuswb_r2r(mm7,mm1);\ | |
1439 movd_r2m(mm1,dst[0]); | |
1440 #endif | |
1441 | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1442 /* filter parameters: [-1 4 2 4 -1] // 8 */ |
2967 | 1443 static void deinterlace_line(uint8_t *dst, |
2979 | 1444 const uint8_t *lum_m4, const uint8_t *lum_m3, |
1445 const uint8_t *lum_m2, const uint8_t *lum_m1, | |
1446 const uint8_t *lum, | |
1447 int size) | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1448 { |
8590 | 1449 #if !HAVE_MMX |
4176 | 1450 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
|
1451 int sum; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1452 |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1453 for(;size > 0;size--) { |
801 | 1454 sum = -lum_m4[0]; |
1455 sum += lum_m3[0] << 2; | |
1456 sum += lum_m2[0] << 1; | |
1457 sum += lum_m1[0] << 2; | |
1458 sum += -lum[0]; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1459 dst[0] = cm[(sum + 4) >> 3]; |
801 | 1460 lum_m4++; |
1461 lum_m3++; | |
1462 lum_m2++; | |
1463 lum_m1++; | |
1464 lum++; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1465 dst++; |
801 | 1466 } |
1467 #else | |
1468 | |
1044 | 1469 { |
1470 pxor_r2r(mm7,mm7); | |
8316 | 1471 movq_m2r(ff_pw_4,mm6); |
1044 | 1472 } |
801 | 1473 for (;size > 3; size-=4) { |
1474 DEINT_LINE_LUM | |
1475 lum_m4+=4; | |
1476 lum_m3+=4; | |
1477 lum_m2+=4; | |
1478 lum_m1+=4; | |
1479 lum+=4; | |
1480 dst+=4; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1481 } |
801 | 1482 #endif |
1483 } | |
1064 | 1484 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 | 1485 int size) |
1486 { | |
8590 | 1487 #if !HAVE_MMX |
4176 | 1488 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
801 | 1489 int sum; |
1490 | |
1491 for(;size > 0;size--) { | |
1492 sum = -lum_m4[0]; | |
1493 sum += lum_m3[0] << 2; | |
1494 sum += lum_m2[0] << 1; | |
1495 lum_m4[0]=lum_m2[0]; | |
1496 sum += lum_m1[0] << 2; | |
1497 sum += -lum[0]; | |
1498 lum_m2[0] = cm[(sum + 4) >> 3]; | |
1499 lum_m4++; | |
1500 lum_m3++; | |
1501 lum_m2++; | |
1502 lum_m1++; | |
1503 lum++; | |
1504 } | |
1505 #else | |
1506 | |
1044 | 1507 { |
1508 pxor_r2r(mm7,mm7); | |
8316 | 1509 movq_m2r(ff_pw_4,mm6); |
1044 | 1510 } |
801 | 1511 for (;size > 3; size-=4) { |
1512 DEINT_INPLACE_LINE_LUM | |
1513 lum_m4+=4; | |
1514 lum_m3+=4; | |
1515 lum_m2+=4; | |
1516 lum_m1+=4; | |
1517 lum+=4; | |
1518 } | |
1519 #endif | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1520 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1521 |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1522 /* 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
|
1523 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
|
1524 against the top field. */ |
1064 | 1525 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
|
1526 const uint8_t *src1, int src_wrap, |
801 | 1527 int width, int height) |
1528 { | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1529 const uint8_t *src_m2, *src_m1, *src_0, *src_p1, *src_p2; |
801 | 1530 int y; |
1531 | |
1532 src_m2 = src1; | |
1533 src_m1 = src1; | |
1534 src_0=&src_m1[src_wrap]; | |
1535 src_p1=&src_0[src_wrap]; | |
1536 src_p2=&src_p1[src_wrap]; | |
1537 for(y=0;y<(height-2);y+=2) { | |
1538 memcpy(dst,src_m1,width); | |
1539 dst += dst_wrap; | |
1540 deinterlace_line(dst,src_m2,src_m1,src_0,src_p1,src_p2,width); | |
1541 src_m2 = src_0; | |
1542 src_m1 = src_p1; | |
1543 src_0 = src_p2; | |
1544 src_p1 += 2*src_wrap; | |
1545 src_p2 += 2*src_wrap; | |
1546 dst += dst_wrap; | |
1547 } | |
1548 memcpy(dst,src_m1,width); | |
1549 dst += dst_wrap; | |
1550 /* do last line */ | |
1551 deinterlace_line(dst,src_m2,src_m1,src_0,src_0,src_0,width); | |
1552 } | |
1553 | |
1064 | 1554 static void deinterlace_bottom_field_inplace(uint8_t *src1, int src_wrap, |
2979 | 1555 int width, int height) |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1556 { |
1064 | 1557 uint8_t *src_m1, *src_0, *src_p1, *src_p2; |
801 | 1558 int y; |
1064 | 1559 uint8_t *buf; |
1560 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
|
1561 |
801 | 1562 src_m1 = src1; |
1563 memcpy(buf,src_m1,width); | |
1564 src_0=&src_m1[src_wrap]; | |
1565 src_p1=&src_0[src_wrap]; | |
1566 src_p2=&src_p1[src_wrap]; | |
1567 for(y=0;y<(height-2);y+=2) { | |
1568 deinterlace_line_inplace(buf,src_m1,src_0,src_p1,src_p2,width); | |
1569 src_m1 = src_p1; | |
1570 src_0 = src_p2; | |
1571 src_p1 += 2*src_wrap; | |
1572 src_p2 += 2*src_wrap; | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1573 } |
801 | 1574 /* do last line */ |
1575 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
|
1576 av_free(buf); |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1577 } |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1578 |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1579 int avpicture_deinterlace(AVPicture *dst, const AVPicture *src, |
9221
a15ec86bf752
Globally prefer enum PixelFormat over int when it makes sense.
stefano
parents:
9217
diff
changeset
|
1580 enum PixelFormat pix_fmt, int width, int height) |
0 | 1581 { |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1582 int i; |
0 | 1583 |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1584 if (pix_fmt != PIX_FMT_YUV420P && |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1585 pix_fmt != PIX_FMT_YUV422P && |
1425
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
1586 pix_fmt != PIX_FMT_YUV444P && |
5810 | 1587 pix_fmt != PIX_FMT_YUV411P && |
1588 pix_fmt != PIX_FMT_GRAY8) | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1589 return -1; |
801 | 1590 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
|
1591 return -1; |
801 | 1592 |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1593 for(i=0;i<3;i++) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1594 if (i == 1) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1595 switch(pix_fmt) { |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1596 case PIX_FMT_YUV420P: |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1597 width >>= 1; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1598 height >>= 1; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1599 break; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1600 case PIX_FMT_YUV422P: |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1601 width >>= 1; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1602 break; |
1425
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
1603 case PIX_FMT_YUV411P: |
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
1604 width >>= 2; |
f53d31c5eac9
* ffmpeg was *silently* rejecting to deinterlace NTSC DV. The problem
romansh
parents:
1353
diff
changeset
|
1605 break; |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1606 default: |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1607 break; |
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1608 } |
5810 | 1609 if (pix_fmt == PIX_FMT_GRAY8) { |
1610 break; | |
1611 } | |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1612 } |
801 | 1613 if (src == dst) { |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1425
diff
changeset
|
1614 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
|
1615 width, height); |
801 | 1616 } else { |
1617 deinterlace_bottom_field(dst->data[i],dst->linesize[i], | |
1618 src->data[i], src->linesize[i], | |
1619 width, height); | |
1620 } | |
0 | 1621 } |
5735 | 1622 emms_c(); |
52
1d796bdb2c2a
added 422P, 444P support - added deinterlace support - added xxx to RGB24 convertion
glantau
parents:
18
diff
changeset
|
1623 return 0; |
0 | 1624 } |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
1625 |