← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libswscale/swscale_unscaled.c

  • Committer: Gauvain Pocentek
  • Date: 2012-03-06 11:59:12 UTC
  • mfrom: (66.1.15 precise)
  • Revision ID: gauvain@pocentek.net-20120306115912-h9d6kt9j0l532oo5
http://bugs.debian.org/442181
http://bugs.debian.org/481807
http://bugs.debian.org/496106
http://bugs.debian.org/533546
http://bugs.debian.org/568514
http://bugs.debian.org/637077
http://bugs.debian.org/638408
http://bugs.debian.org/643621
http://bugs.debian.org/650339
http://bugs.debian.org/653887
http://bugs.debian.org/654974
* Merge from Ubuntu:
  - put back faac support
  - recommends apport-hooks-medibuntu
  - change Maintainer, Uploaders & Vcs-* fields.
* New upstream snapshot
* upload to unstable
* Build against external libmpeg2
* drop 51_FTBFS_arm.patch again
* no longer build depend on libcdparanoia-dev on the Hurd
* Fix FTBFS on the hurd.
  Thanks to Samuel Thibault <sthibault@debian.org> (Closes: #654974)
* Fix FTBFS on arm
* New upstream snapshot, Closes: #650339, #643621, #481807
* Imported Upstream version 1.0~rc4+svn34492
* Bump standards version
* Bump dependency on libav >= 4:0.8~, Closes: #653887
* Fix build-indep
* Build mplayer-gui again, Closes: #568514
* Drop debian/all-lang-config-mak.sh, no longer needed
* include .dfsg1 in version number
* remove get-orig-source target
* no longer prune compiler flags from the environment
* No longer advertise nor build 3fdx, mga and dxr3 backends,
  Closes: #496106, #442181, #533546
* beautify mplayer version identification string
* Brown paperbag upload.
* Next try to fix build failure on sparce after recent binutils change.
* Brown paperbag upload.
* Really fix build failure on sparc after recent binutils change.
* Properly set Replaces/Conflicts on mplayer2{,-dbg} to avoid
  file overwrite errors.
* Adjust versioning of mplayer listed in the mplayer-dbg's Depends field.
* Fix build failure on sparc after recent binutils change.
* Urgency medium bumped because of RC-level bugfix
  and speeding up x264 transition.
* Update to my @debian.org email.
* Upload to unstable
* Enable joystick support on Linux only, Closes: #638408
* Rebuild fixes toolchain issue on arm, Closes: #637077
* New upstream snapshot
* following the discussion started by Diego Biurrun <diego@biurrun.de>
  in debian-devel, I have prepared a new packaging of 'mplayer'
  (with code that comes from CVS)
* the upstream tar.bz cannot be distributed by Debian, since it contains
   CSS code; so I am repackaging it 
* I have tried my best to address all known issues:
  - the package contains the detailed Copyright made by Diego Biurrun 
  - the package does not contain CSS code, or  AFAIK other code on which 
     there is active patent enforcement
  - there is a script  debian/cvs-changelog.sh  that shows all changes
     done to files included in this source.
    This should comply with GPLv2 sec 2.a  (in spirit if not in letter)
    For this reason, the source code contains CVS directories.
* needs   make (>= 3.80) for 'html-chunked-$(1)' in DOCS/xml/Makefile

* some corrections, as suggested Diego Biurrun
  - binary codecs should go into /usr/lib/codecs (upstream default)
  - better template 'mplayer/install_codecs'
  - an empty 'font=' in mplayer.conf breaks mplayer: postinst corrected
* correction in 'mplayer/cfgnote'
* better mplayer.postinst and mplayer.config

* New upstream release
* better debian/copyright file
* do not ship a skin
* New upstream release
* changed DEB_BUILD_OPTIONS to DEB_BUILD_CONFIGURE ,
  DEB_BUILD_OPTIONS is used as in debian policy
* use gcc-3.4
* changed xlibs-dev to a long list of dependencies, for Debian/etch
* try to adhere to  http://www.mplayerhq.hu/DOCS/tech/binary-packaging.txt
  (see README.Debian for details)
* removed dependency on xlibmesa-dev, disabled opengl
* New upstream release
* Simon McVittie <hacks@pseudorandom.co.uk> wonderful work:
- Work around Debian bug #267442 (glibc's sys/uio.h and gcc's altivec.h have
  conflicting uses for __vector) by re-ordering #includes
- Fix potential symlink attack in ./configure
- Disable support for binary codecs on platforms for which those codecs
  aren't available; also disable the corresponding Debconf note when it's
  inappropriate
- Changed Build-Depends: so it works in pbuilder
- Explicitly build-depend on libjpeg62-dev, libfontconfig1-dev,
  libungif4-dev 
- Tweak debian/rules to avoid certain errors being ignored
- Use --language=all
* provide a target  'debian/rules get-orig-source' 
  that recreates the orig.tar.gz ; then use the above orig.tar.gz
* rewrote some parts of debian/rules
* don't clean and recompile docs if upstream ships them
* mplayer-doc was shipping too much stuff
* translated man pages where not installed properly
* compile with libdv4-dev
* correct README.Debian
* Forgot build-dep on libtheora
* Must not depend on libxvidcore
* New upstream release
* new release.
* rc1 to become 0.90
* new pre-release
* new pre-release
* gtk bug fixed.
* new release.
* version bumped
* 0.60 pre2 release
* 0.60 pre-release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libswscale/swscale_unscaled.c
34
34
#include "libavutil/bswap.h"
35
35
#include "libavutil/pixdesc.h"
36
36
 
 
37
DECLARE_ALIGNED(8, const uint8_t, dither_8x8_1)[8][8] = {
 
38
    {   0,  1,  0,  1,  0,  1,  0,  1,},
 
39
    {   1,  0,  1,  0,  1,  0,  1,  0,},
 
40
    {   0,  1,  0,  1,  0,  1,  0,  1,},
 
41
    {   1,  0,  1,  0,  1,  0,  1,  0,},
 
42
    {   0,  1,  0,  1,  0,  1,  0,  1,},
 
43
    {   1,  0,  1,  0,  1,  0,  1,  0,},
 
44
    {   0,  1,  0,  1,  0,  1,  0,  1,},
 
45
    {   1,  0,  1,  0,  1,  0,  1,  0,},
 
46
};
 
47
DECLARE_ALIGNED(8, const uint8_t, dither_8x8_3)[8][8] = {
 
48
    {   1,  2,  1,  2,  1,  2,  1,  2,},
 
49
    {   3,  0,  3,  0,  3,  0,  3,  0,},
 
50
    {   1,  2,  1,  2,  1,  2,  1,  2,},
 
51
    {   3,  0,  3,  0,  3,  0,  3,  0,},
 
52
    {   1,  2,  1,  2,  1,  2,  1,  2,},
 
53
    {   3,  0,  3,  0,  3,  0,  3,  0,},
 
54
    {   1,  2,  1,  2,  1,  2,  1,  2,},
 
55
    {   3,  0,  3,  0,  3,  0,  3,  0,},
 
56
};
 
57
DECLARE_ALIGNED(8, const uint8_t, dither_8x8_64)[8][8] = {
 
58
    {  18, 34, 30, 46, 17, 33, 29, 45,},
 
59
    {  50,  2, 62, 14, 49,  1, 61, 13,},
 
60
    {  26, 42, 22, 38, 25, 41, 21, 37,},
 
61
    {  58, 10, 54,  6, 57,  9, 53,  5,},
 
62
    {  16, 32, 28, 44, 19, 35, 31, 47,},
 
63
    {  48,  0, 60, 12, 51,  3, 63, 15,},
 
64
    {  24, 40, 20, 36, 27, 43, 23, 39,},
 
65
    {  56,  8, 52,  4, 59, 11, 55,  7,},
 
66
};
 
67
extern const uint8_t dither_8x8_128[8][8];
 
68
DECLARE_ALIGNED(8, const uint8_t, dither_8x8_256)[8][8] = {
 
69
    {  72, 136, 120, 184,  68, 132, 116, 180,},
 
70
    { 200,   8, 248,  56, 196,   4, 244,  52,},
 
71
    { 104, 168,  88, 152, 100, 164,  84, 148,},
 
72
    { 232,  40, 216,  24, 228,  36, 212,  20,},
 
73
    {  64, 128, 102, 176,  76, 140, 124, 188,},
 
74
    { 192,   0, 240,  48, 204,  12, 252,  60,},
 
75
    {  96, 160,  80, 144, 108, 172,  92, 156,},
 
76
    { 224,  32, 208,  16, 236,  44, 220,  28,},
 
77
};
 
78
 
37
79
#define RGB2YUV_SHIFT 15
38
 
#define BY ( (int)(0.114*219/255*(1<<RGB2YUV_SHIFT)+0.5))
39
 
#define BV (-(int)(0.081*224/255*(1<<RGB2YUV_SHIFT)+0.5))
40
 
#define BU ( (int)(0.500*224/255*(1<<RGB2YUV_SHIFT)+0.5))
41
 
#define GY ( (int)(0.587*219/255*(1<<RGB2YUV_SHIFT)+0.5))
42
 
#define GV (-(int)(0.419*224/255*(1<<RGB2YUV_SHIFT)+0.5))
43
 
#define GU (-(int)(0.331*224/255*(1<<RGB2YUV_SHIFT)+0.5))
44
 
#define RY ( (int)(0.299*219/255*(1<<RGB2YUV_SHIFT)+0.5))
45
 
#define RV ( (int)(0.500*224/255*(1<<RGB2YUV_SHIFT)+0.5))
46
 
#define RU (-(int)(0.169*224/255*(1<<RGB2YUV_SHIFT)+0.5))
 
80
#define BY ( (int) (0.114 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 
81
#define BV (-(int) (0.081 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 
82
#define BU ( (int) (0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 
83
#define GY ( (int) (0.587 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 
84
#define GV (-(int) (0.419 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 
85
#define GU (-(int) (0.331 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 
86
#define RY ( (int) (0.299 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 
87
#define RV ( (int) (0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 
88
#define RU (-(int) (0.169 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
47
89
 
48
 
static void fillPlane(uint8_t* plane, int stride, int width, int height, int y, uint8_t val)
 
90
static void fillPlane(uint8_t *plane, int stride, int width, int height, int y,
 
91
                      uint8_t val)
49
92
{
50
93
    int i;
51
 
    uint8_t *ptr = plane + stride*y;
52
 
    for (i=0; i<height; i++) {
 
94
    uint8_t *ptr = plane + stride * y;
 
95
    for (i = 0; i < height; i++) {
53
96
        memset(ptr, val, width);
54
97
        ptr += stride;
55
98
    }
64
107
        memcpy(dst, src, srcSliceH * dstStride);
65
108
    } else {
66
109
        int i;
67
 
        for (i=0; i<srcSliceH; i++) {
 
110
        for (i = 0; i < srcSliceH; i++) {
68
111
            memcpy(dst, src, width);
69
112
            src += srcStride;
70
113
            dst += dstStride;
72
115
    }
73
116
}
74
117
 
75
 
static int planarToNv12Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
76
 
                               int srcSliceH, uint8_t* dstParam[], int dstStride[])
 
118
static int planarToNv12Wrapper(SwsContext *c, const uint8_t *src[],
 
119
                               int srcStride[], int srcSliceY,
 
120
                               int srcSliceH, uint8_t *dstParam[],
 
121
                               int dstStride[])
77
122
{
78
 
    uint8_t *dst = dstParam[1] + dstStride[1]*srcSliceY/2;
 
123
    uint8_t *dst = dstParam[1] + dstStride[1] * srcSliceY / 2;
79
124
 
80
125
    copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
81
126
              dstParam[0], dstStride[0]);
82
127
 
83
128
    if (c->dstFormat == PIX_FMT_NV12)
84
 
        interleaveBytes(src[1], src[2], dst, c->srcW/2, srcSliceH/2, srcStride[1], srcStride[2], dstStride[0]);
 
129
        interleaveBytes(src[1], src[2], dst, c->srcW / 2, srcSliceH / 2,
 
130
                        srcStride[1], srcStride[2], dstStride[0]);
85
131
    else
86
 
        interleaveBytes(src[2], src[1], dst, c->srcW/2, srcSliceH/2, srcStride[2], srcStride[1], dstStride[0]);
87
 
 
88
 
    return srcSliceH;
89
 
}
90
 
 
91
 
static int planarToYuy2Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
92
 
                               int srcSliceH, uint8_t* dstParam[], int dstStride[])
93
 
{
94
 
    uint8_t *dst=dstParam[0] + dstStride[0]*srcSliceY;
95
 
 
96
 
    yv12toyuy2(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0], srcStride[1], dstStride[0]);
97
 
 
98
 
    return srcSliceH;
99
 
}
100
 
 
101
 
static int planarToUyvyWrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
102
 
                               int srcSliceH, uint8_t* dstParam[], int dstStride[])
103
 
{
104
 
    uint8_t *dst=dstParam[0] + dstStride[0]*srcSliceY;
105
 
 
106
 
    yv12touyvy(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0], srcStride[1], dstStride[0]);
107
 
 
108
 
    return srcSliceH;
109
 
}
110
 
 
111
 
static int yuv422pToYuy2Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
112
 
                                int srcSliceH, uint8_t* dstParam[], int dstStride[])
113
 
{
114
 
    uint8_t *dst=dstParam[0] + dstStride[0]*srcSliceY;
115
 
 
116
 
    yuv422ptoyuy2(src[0],src[1],src[2],dst,c->srcW,srcSliceH,srcStride[0],srcStride[1],dstStride[0]);
117
 
 
118
 
    return srcSliceH;
119
 
}
120
 
 
121
 
static int yuv422pToUyvyWrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
122
 
                                int srcSliceH, uint8_t* dstParam[], int dstStride[])
123
 
{
124
 
    uint8_t *dst=dstParam[0] + dstStride[0]*srcSliceY;
125
 
 
126
 
    yuv422ptouyvy(src[0],src[1],src[2],dst,c->srcW,srcSliceH,srcStride[0],srcStride[1],dstStride[0]);
127
 
 
128
 
    return srcSliceH;
129
 
}
130
 
 
131
 
static int yuyvToYuv420Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
132
 
                               int srcSliceH, uint8_t* dstParam[], int dstStride[])
133
 
{
134
 
    uint8_t *ydst=dstParam[0] + dstStride[0]*srcSliceY;
135
 
    uint8_t *udst=dstParam[1] + dstStride[1]*srcSliceY/2;
136
 
    uint8_t *vdst=dstParam[2] + dstStride[2]*srcSliceY/2;
137
 
 
138
 
    yuyvtoyuv420(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0], dstStride[1], srcStride[0]);
139
 
 
140
 
    if (dstParam[3])
141
 
        fillPlane(dstParam[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
142
 
 
143
 
    return srcSliceH;
144
 
}
145
 
 
146
 
static int yuyvToYuv422Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
147
 
                               int srcSliceH, uint8_t* dstParam[], int dstStride[])
148
 
{
149
 
    uint8_t *ydst=dstParam[0] + dstStride[0]*srcSliceY;
150
 
    uint8_t *udst=dstParam[1] + dstStride[1]*srcSliceY;
151
 
    uint8_t *vdst=dstParam[2] + dstStride[2]*srcSliceY;
152
 
 
153
 
    yuyvtoyuv422(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0], dstStride[1], srcStride[0]);
154
 
 
155
 
    return srcSliceH;
156
 
}
157
 
 
158
 
static int uyvyToYuv420Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
159
 
                               int srcSliceH, uint8_t* dstParam[], int dstStride[])
160
 
{
161
 
    uint8_t *ydst=dstParam[0] + dstStride[0]*srcSliceY;
162
 
    uint8_t *udst=dstParam[1] + dstStride[1]*srcSliceY/2;
163
 
    uint8_t *vdst=dstParam[2] + dstStride[2]*srcSliceY/2;
164
 
 
165
 
    uyvytoyuv420(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0], dstStride[1], srcStride[0]);
166
 
 
167
 
    if (dstParam[3])
168
 
        fillPlane(dstParam[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
169
 
 
170
 
    return srcSliceH;
171
 
}
172
 
 
173
 
static int uyvyToYuv422Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
174
 
                               int srcSliceH, uint8_t* dstParam[], int dstStride[])
175
 
{
176
 
    uint8_t *ydst=dstParam[0] + dstStride[0]*srcSliceY;
177
 
    uint8_t *udst=dstParam[1] + dstStride[1]*srcSliceY;
178
 
    uint8_t *vdst=dstParam[2] + dstStride[2]*srcSliceY;
179
 
 
180
 
    uyvytoyuv422(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0], dstStride[1], srcStride[0]);
181
 
 
182
 
    return srcSliceH;
183
 
}
184
 
 
185
 
static void gray8aToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
186
 
{
187
 
    int i;
188
 
    for (i=0; i<num_pixels; i++)
189
 
        ((uint32_t *) dst)[i] = ((const uint32_t *)palette)[src[i<<1]] | (src[(i<<1)+1] << 24);
190
 
}
191
 
 
192
 
static void gray8aToPacked32_1(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
193
 
{
194
 
    int i;
195
 
 
196
 
    for (i=0; i<num_pixels; i++)
197
 
        ((uint32_t *) dst)[i] = ((const uint32_t *)palette)[src[i<<1]] | src[(i<<1)+1];
198
 
}
199
 
 
200
 
static void gray8aToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
201
 
{
202
 
    int i;
203
 
 
204
 
    for (i=0; i<num_pixels; i++) {
 
132
        interleaveBytes(src[2], src[1], dst, c->srcW / 2, srcSliceH / 2,
 
133
                        srcStride[2], srcStride[1], dstStride[0]);
 
134
 
 
135
    return srcSliceH;
 
136
}
 
137
 
 
138
static int planarToYuy2Wrapper(SwsContext *c, const uint8_t *src[],
 
139
                               int srcStride[], int srcSliceY, int srcSliceH,
 
140
                               uint8_t *dstParam[], int dstStride[])
 
141
{
 
142
    uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
 
143
 
 
144
    yv12toyuy2(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
 
145
               srcStride[1], dstStride[0]);
 
146
 
 
147
    return srcSliceH;
 
148
}
 
149
 
 
150
static int planarToUyvyWrapper(SwsContext *c, const uint8_t *src[],
 
151
                               int srcStride[], int srcSliceY, int srcSliceH,
 
152
                               uint8_t *dstParam[], int dstStride[])
 
153
{
 
154
    uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
 
155
 
 
156
    yv12touyvy(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
 
157
               srcStride[1], dstStride[0]);
 
158
 
 
159
    return srcSliceH;
 
160
}
 
161
 
 
162
static int yuv422pToYuy2Wrapper(SwsContext *c, const uint8_t *src[],
 
163
                                int srcStride[], int srcSliceY, int srcSliceH,
 
164
                                uint8_t *dstParam[], int dstStride[])
 
165
{
 
166
    uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
 
167
 
 
168
    yuv422ptoyuy2(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
 
169
                  srcStride[1], dstStride[0]);
 
170
 
 
171
    return srcSliceH;
 
172
}
 
173
 
 
174
static int yuv422pToUyvyWrapper(SwsContext *c, const uint8_t *src[],
 
175
                                int srcStride[], int srcSliceY, int srcSliceH,
 
176
                                uint8_t *dstParam[], int dstStride[])
 
177
{
 
178
    uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
 
179
 
 
180
    yuv422ptouyvy(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
 
181
                  srcStride[1], dstStride[0]);
 
182
 
 
183
    return srcSliceH;
 
184
}
 
185
 
 
186
static int yuyvToYuv420Wrapper(SwsContext *c, const uint8_t *src[],
 
187
                               int srcStride[], int srcSliceY, int srcSliceH,
 
188
                               uint8_t *dstParam[], int dstStride[])
 
189
{
 
190
    uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
 
191
    uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY / 2;
 
192
    uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY / 2;
 
193
 
 
194
    yuyvtoyuv420(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
 
195
                 dstStride[1], srcStride[0]);
 
196
 
 
197
    if (dstParam[3])
 
198
        fillPlane(dstParam[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
 
199
 
 
200
    return srcSliceH;
 
201
}
 
202
 
 
203
static int yuyvToYuv422Wrapper(SwsContext *c, const uint8_t *src[],
 
204
                               int srcStride[], int srcSliceY, int srcSliceH,
 
205
                               uint8_t *dstParam[], int dstStride[])
 
206
{
 
207
    uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
 
208
    uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY;
 
209
    uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY;
 
210
 
 
211
    yuyvtoyuv422(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
 
212
                 dstStride[1], srcStride[0]);
 
213
 
 
214
    return srcSliceH;
 
215
}
 
216
 
 
217
static int uyvyToYuv420Wrapper(SwsContext *c, const uint8_t *src[],
 
218
                               int srcStride[], int srcSliceY, int srcSliceH,
 
219
                               uint8_t *dstParam[], int dstStride[])
 
220
{
 
221
    uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
 
222
    uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY / 2;
 
223
    uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY / 2;
 
224
 
 
225
    uyvytoyuv420(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
 
226
                 dstStride[1], srcStride[0]);
 
227
 
 
228
    if (dstParam[3])
 
229
        fillPlane(dstParam[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
 
230
 
 
231
    return srcSliceH;
 
232
}
 
233
 
 
234
static int uyvyToYuv422Wrapper(SwsContext *c, const uint8_t *src[],
 
235
                               int srcStride[], int srcSliceY, int srcSliceH,
 
236
                               uint8_t *dstParam[], int dstStride[])
 
237
{
 
238
    uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
 
239
    uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY;
 
240
    uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY;
 
241
 
 
242
    uyvytoyuv422(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
 
243
                 dstStride[1], srcStride[0]);
 
244
 
 
245
    return srcSliceH;
 
246
}
 
247
 
 
248
static void gray8aToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels,
 
249
                             const uint8_t *palette)
 
250
{
 
251
    int i;
 
252
    for (i = 0; i < num_pixels; i++)
 
253
        ((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i << 1]] | (src[(i << 1) + 1] << 24);
 
254
}
 
255
 
 
256
static void gray8aToPacked32_1(const uint8_t *src, uint8_t *dst, int num_pixels,
 
257
                               const uint8_t *palette)
 
258
{
 
259
    int i;
 
260
 
 
261
    for (i = 0; i < num_pixels; i++)
 
262
        ((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i << 1]] | src[(i << 1) + 1];
 
263
}
 
264
 
 
265
static void gray8aToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels,
 
266
                             const uint8_t *palette)
 
267
{
 
268
    int i;
 
269
 
 
270
    for (i = 0; i < num_pixels; i++) {
205
271
        //FIXME slow?
206
 
        dst[0]= palette[src[i<<1]*4+0];
207
 
        dst[1]= palette[src[i<<1]*4+1];
208
 
        dst[2]= palette[src[i<<1]*4+2];
209
 
        dst+= 3;
210
 
    }
211
 
}
212
 
 
213
 
static int palToRgbWrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
214
 
                           int srcSliceH, uint8_t* dst[], int dstStride[])
215
 
{
216
 
    const enum PixelFormat srcFormat= c->srcFormat;
217
 
    const enum PixelFormat dstFormat= c->dstFormat;
 
272
        dst[0] = palette[src[i << 1] * 4 + 0];
 
273
        dst[1] = palette[src[i << 1] * 4 + 1];
 
274
        dst[2] = palette[src[i << 1] * 4 + 2];
 
275
        dst += 3;
 
276
    }
 
277
}
 
278
 
 
279
static int packed_16bpc_bswap(SwsContext *c, const uint8_t *src[],
 
280
                              int srcStride[], int srcSliceY, int srcSliceH,
 
281
                              uint8_t *dst[], int dstStride[])
 
282
{
 
283
    int i, j;
 
284
    int srcstr = srcStride[0] >> 1;
 
285
    int dststr = dstStride[0] >> 1;
 
286
    uint16_t       *dstPtr =       (uint16_t *) dst[0];
 
287
    const uint16_t *srcPtr = (const uint16_t *) src[0];
 
288
    int min_stride         = FFMIN(srcstr, dststr);
 
289
 
 
290
    for (i = 0; i < srcSliceH; i++) {
 
291
        for (j = 0; j < min_stride; j++) {
 
292
            dstPtr[j] = av_bswap16(srcPtr[j]);
 
293
        }
 
294
        srcPtr += srcstr;
 
295
        dstPtr += dststr;
 
296
    }
 
297
 
 
298
    return srcSliceH;
 
299
}
 
300
 
 
301
static int palToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[],
 
302
                           int srcSliceY, int srcSliceH, uint8_t *dst[],
 
303
                           int dstStride[])
 
304
{
 
305
    const enum PixelFormat srcFormat = c->srcFormat;
 
306
    const enum PixelFormat dstFormat = c->dstFormat;
218
307
    void (*conv)(const uint8_t *src, uint8_t *dst, int num_pixels,
219
 
                 const uint8_t *palette)=NULL;
 
308
                 const uint8_t *palette) = NULL;
220
309
    int i;
221
 
    uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
222
 
    const uint8_t *srcPtr= src[0];
 
310
    uint8_t *dstPtr = dst[0] + dstStride[0] * srcSliceY;
 
311
    const uint8_t *srcPtr = src[0];
223
312
 
224
313
    if (srcFormat == PIX_FMT_Y400A) {
225
314
        switch (dstFormat) {
245
334
        av_log(c, AV_LOG_ERROR, "internal error %s -> %s converter\n",
246
335
               sws_format_name(srcFormat), sws_format_name(dstFormat));
247
336
    else {
248
 
        for (i=0; i<srcSliceH; i++) {
 
337
        for (i = 0; i < srcSliceH; i++) {
249
338
            conv(srcPtr, dstPtr, c->srcW, (uint8_t *) c->pal_rgb);
250
 
            srcPtr+= srcStride[0];
251
 
            dstPtr+= dstStride[0];
 
339
            srcPtr += srcStride[0];
 
340
            dstPtr += dstStride[0];
252
341
        }
253
342
    }
254
343
 
263
352
        )
264
353
 
265
354
/* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
266
 
static int rgbToRgbWrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
267
 
                           int srcSliceH, uint8_t* dst[], int dstStride[])
 
355
static int rgbToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[],
 
356
                           int srcSliceY, int srcSliceH, uint8_t *dst[],
 
357
                           int dstStride[])
268
358
{
269
 
    const enum PixelFormat srcFormat= c->srcFormat;
270
 
    const enum PixelFormat dstFormat= c->dstFormat;
271
 
    const int srcBpp= (c->srcFormatBpp + 7) >> 3;
272
 
    const int dstBpp= (c->dstFormatBpp + 7) >> 3;
273
 
    const int srcId= c->srcFormatBpp >> 2; /* 1:0, 4:1, 8:2, 15:3, 16:4, 24:6, 32:8 */
274
 
    const int dstId= c->dstFormatBpp >> 2;
275
 
    void (*conv)(const uint8_t *src, uint8_t *dst, int src_size)=NULL;
 
359
    const enum PixelFormat srcFormat = c->srcFormat;
 
360
    const enum PixelFormat dstFormat = c->dstFormat;
 
361
    const int srcBpp = (c->srcFormatBpp + 7) >> 3;
 
362
    const int dstBpp = (c->dstFormatBpp + 7) >> 3;
 
363
    const int srcId = c->srcFormatBpp;
 
364
    const int dstId = c->dstFormatBpp;
 
365
    void (*conv)(const uint8_t *src, uint8_t *dst, int src_size) = NULL;
276
366
 
277
367
#define CONV_IS(src, dst) (srcFormat == PIX_FMT_##src && dstFormat == PIX_FMT_##dst)
278
368
 
291
381
              || CONV_IS(RGBA, ARGB)) conv = shuffle_bytes_3012;
292
382
    } else
293
383
    /* BGR -> BGR */
294
 
    if (  (isBGRinInt(srcFormat) && isBGRinInt(dstFormat))
295
 
       || (isRGBinInt(srcFormat) && isRGBinInt(dstFormat))) {
296
 
        switch(srcId | (dstId<<4)) {
297
 
        case 0x34: conv= rgb16to15; break;
298
 
        case 0x36: conv= rgb24to15; break;
299
 
        case 0x38: conv= rgb32to15; break;
300
 
        case 0x43: conv= rgb15to16; break;
301
 
        case 0x46: conv= rgb24to16; break;
302
 
        case 0x48: conv= rgb32to16; break;
303
 
        case 0x63: conv= rgb15to24; break;
304
 
        case 0x64: conv= rgb16to24; break;
305
 
        case 0x68: conv= rgb32to24; break;
306
 
        case 0x83: conv= rgb15to32; break;
307
 
        case 0x84: conv= rgb16to32; break;
308
 
        case 0x86: conv= rgb24to32; break;
 
384
    if ((isBGRinInt(srcFormat) && isBGRinInt(dstFormat)) ||
 
385
        (isRGBinInt(srcFormat) && isRGBinInt(dstFormat))) {
 
386
        switch (srcId | (dstId << 16)) {
 
387
        case 0x000F0010: conv = rgb16to15; break;
 
388
        case 0x000F0018: conv = rgb24to15; break;
 
389
        case 0x000F0020: conv = rgb32to15; break;
 
390
        case 0x0010000F: conv = rgb15to16; break;
 
391
        case 0x00100018: conv = rgb24to16; break;
 
392
        case 0x00100020: conv = rgb32to16; break;
 
393
        case 0x0018000F: conv = rgb15to24; break;
 
394
        case 0x00180010: conv = rgb16to24; break;
 
395
        case 0x00180020: conv = rgb32to24; break;
 
396
        case 0x0020000F: conv = rgb15to32; break;
 
397
        case 0x00200010: conv = rgb16to32; break;
 
398
        case 0x00200018: conv = rgb24to32; break;
309
399
        }
310
 
    } else if (  (isBGRinInt(srcFormat) && isRGBinInt(dstFormat))
311
 
             || (isRGBinInt(srcFormat) && isBGRinInt(dstFormat))) {
312
 
        switch(srcId | (dstId<<4)) {
313
 
        case 0x33: conv= rgb15tobgr15; break;
314
 
        case 0x34: conv= rgb16tobgr15; break;
315
 
        case 0x36: conv= rgb24tobgr15; break;
316
 
        case 0x38: conv= rgb32tobgr15; break;
317
 
        case 0x43: conv= rgb15tobgr16; break;
318
 
        case 0x44: conv= rgb16tobgr16; break;
319
 
        case 0x46: conv= rgb24tobgr16; break;
320
 
        case 0x48: conv= rgb32tobgr16; break;
321
 
        case 0x63: conv= rgb15tobgr24; break;
322
 
        case 0x64: conv= rgb16tobgr24; break;
323
 
        case 0x66: conv= rgb24tobgr24; break;
324
 
        case 0x68: conv= rgb32tobgr24; break;
325
 
        case 0x83: conv= rgb15tobgr32; break;
326
 
        case 0x84: conv= rgb16tobgr32; break;
327
 
        case 0x86: conv= rgb24tobgr32; break;
 
400
    } else if ((isBGRinInt(srcFormat) && isRGBinInt(dstFormat)) ||
 
401
               (isRGBinInt(srcFormat) && isBGRinInt(dstFormat))) {
 
402
        switch (srcId | (dstId << 16)) {
 
403
        case 0x000F000F: conv = rgb15tobgr15; break;
 
404
        case 0x000F0010: conv = rgb16tobgr15; break;
 
405
        case 0x000F0018: conv = rgb24tobgr15; break;
 
406
        case 0x000F0020: conv = rgb32tobgr15; break;
 
407
        case 0x0010000F: conv = rgb15tobgr16; break;
 
408
        case 0x00100010: conv = rgb16tobgr16; break;
 
409
        case 0x00100018: conv = rgb24tobgr16; break;
 
410
        case 0x00100020: conv = rgb32tobgr16; break;
 
411
        case 0x0018000F: conv = rgb15tobgr24; break;
 
412
        case 0x00180010: conv = rgb16tobgr24; break;
 
413
        case 0x00180018: conv = rgb24tobgr24; break;
 
414
        case 0x00180020: conv = rgb32tobgr24; break;
 
415
        case 0x0020000F: conv = rgb15tobgr32; break;
 
416
        case 0x00200010: conv = rgb16tobgr32; break;
 
417
        case 0x00200018: conv = rgb24tobgr32; break;
328
418
        }
329
419
    }
330
420
 
332
422
        av_log(c, AV_LOG_ERROR, "internal error %s -> %s converter\n",
333
423
               sws_format_name(srcFormat), sws_format_name(dstFormat));
334
424
    } else {
335
 
        const uint8_t *srcPtr= src[0];
336
 
              uint8_t *dstPtr= dst[0];
337
 
        if ((srcFormat == PIX_FMT_RGB32_1 || srcFormat == PIX_FMT_BGR32_1) && !isRGBA32(dstFormat))
 
425
        const uint8_t *srcPtr = src[0];
 
426
              uint8_t *dstPtr = dst[0];
 
427
        if ((srcFormat == PIX_FMT_RGB32_1 || srcFormat == PIX_FMT_BGR32_1) &&
 
428
            !isRGBA32(dstFormat))
338
429
            srcPtr += ALT32_CORR;
339
430
 
340
 
        if ((dstFormat == PIX_FMT_RGB32_1 || dstFormat == PIX_FMT_BGR32_1) && !isRGBA32(srcFormat))
 
431
        if ((dstFormat == PIX_FMT_RGB32_1 || dstFormat == PIX_FMT_BGR32_1) &&
 
432
            !isRGBA32(srcFormat))
341
433
            dstPtr += ALT32_CORR;
342
434
 
343
 
        if (dstStride[0]*srcBpp == srcStride[0]*dstBpp && srcStride[0] > 0)
344
 
            conv(srcPtr, dstPtr + dstStride[0]*srcSliceY, srcSliceH*srcStride[0]);
 
435
        if (dstStride[0] * srcBpp == srcStride[0] * dstBpp && srcStride[0] > 0 &&
 
436
            !(srcStride[0] % srcBpp))
 
437
            conv(srcPtr, dstPtr + dstStride[0] * srcSliceY,
 
438
                 srcSliceH * srcStride[0]);
345
439
        else {
346
440
            int i;
347
 
            dstPtr += dstStride[0]*srcSliceY;
 
441
            dstPtr += dstStride[0] * srcSliceY;
348
442
 
349
 
            for (i=0; i<srcSliceH; i++) {
350
 
                conv(srcPtr, dstPtr, c->srcW*srcBpp);
351
 
                srcPtr+= srcStride[0];
352
 
                dstPtr+= dstStride[0];
 
443
            for (i = 0; i < srcSliceH; i++) {
 
444
                conv(srcPtr, dstPtr, c->srcW * srcBpp);
 
445
                srcPtr += srcStride[0];
 
446
                dstPtr += dstStride[0];
353
447
            }
354
448
        }
355
449
    }
356
450
    return srcSliceH;
357
451
}
358
452
 
359
 
static int bgr24ToYv12Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
360
 
                              int srcSliceH, uint8_t* dst[], int dstStride[])
 
453
static int bgr24ToYv12Wrapper(SwsContext *c, const uint8_t *src[],
 
454
                              int srcStride[], int srcSliceY, int srcSliceH,
 
455
                              uint8_t *dst[], int dstStride[])
361
456
{
362
457
    rgb24toyv12(
363
458
        src[0],
364
 
        dst[0]+ srcSliceY    *dstStride[0],
365
 
        dst[1]+(srcSliceY>>1)*dstStride[1],
366
 
        dst[2]+(srcSliceY>>1)*dstStride[2],
 
459
        dst[0] +  srcSliceY       * dstStride[0],
 
460
        dst[1] + (srcSliceY >> 1) * dstStride[1],
 
461
        dst[2] + (srcSliceY >> 1) * dstStride[2],
367
462
        c->srcW, srcSliceH,
368
463
        dstStride[0], dstStride[1], srcStride[0]);
369
464
    if (dst[3])
371
466
    return srcSliceH;
372
467
}
373
468
 
374
 
static int yvu9ToYv12Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
375
 
                             int srcSliceH, uint8_t* dst[], int dstStride[])
 
469
static int yvu9ToYv12Wrapper(SwsContext *c, const uint8_t *src[],
 
470
                             int srcStride[], int srcSliceY, int srcSliceH,
 
471
                             uint8_t *dst[], int dstStride[])
376
472
{
377
473
    copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
378
474
              dst[0], dstStride[0]);
379
475
 
380
 
    planar2x(src[1], dst[1] + dstStride[1]*(srcSliceY >> 1), c->chrSrcW,
 
476
    planar2x(src[1], dst[1] + dstStride[1] * (srcSliceY >> 1), c->chrSrcW,
381
477
             srcSliceH >> 2, srcStride[1], dstStride[1]);
382
 
    planar2x(src[2], dst[2] + dstStride[2]*(srcSliceY >> 1), c->chrSrcW,
 
478
    planar2x(src[2], dst[2] + dstStride[2] * (srcSliceY >> 1), c->chrSrcW,
383
479
             srcSliceH >> 2, srcStride[2], dstStride[2]);
384
480
    if (dst[3])
385
481
        fillPlane(dst[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
387
483
}
388
484
 
389
485
/* unscaled copy like stuff (assumes nearly identical formats) */
390
 
static int packedCopyWrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
391
 
                             int srcSliceH, uint8_t* dst[], int dstStride[])
 
486
static int packedCopyWrapper(SwsContext *c, const uint8_t *src[],
 
487
                             int srcStride[], int srcSliceY, int srcSliceH,
 
488
                             uint8_t *dst[], int dstStride[])
392
489
{
393
 
    if (dstStride[0]==srcStride[0] && srcStride[0] > 0)
394
 
        memcpy(dst[0] + dstStride[0]*srcSliceY, src[0], srcSliceH*dstStride[0]);
 
490
    if (dstStride[0] == srcStride[0] && srcStride[0] > 0)
 
491
        memcpy(dst[0] + dstStride[0] * srcSliceY, src[0], srcSliceH * dstStride[0]);
395
492
    else {
396
493
        int i;
397
 
        const uint8_t *srcPtr= src[0];
398
 
        uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
399
 
        int length=0;
 
494
        const uint8_t *srcPtr = src[0];
 
495
        uint8_t *dstPtr = dst[0] + dstStride[0] * srcSliceY;
 
496
        int length = 0;
400
497
 
401
498
        /* universal length finder */
402
 
        while(length+c->srcW <= FFABS(dstStride[0])
403
 
           && length+c->srcW <= FFABS(srcStride[0])) length+= c->srcW;
404
 
        assert(length!=0);
 
499
        while (length + c->srcW <= FFABS(dstStride[0]) &&
 
500
               length + c->srcW <= FFABS(srcStride[0]))
 
501
            length += c->srcW;
 
502
        assert(length != 0);
405
503
 
406
 
        for (i=0; i<srcSliceH; i++) {
 
504
        for (i = 0; i < srcSliceH; i++) {
407
505
            memcpy(dstPtr, srcPtr, length);
408
 
            srcPtr+= srcStride[0];
409
 
            dstPtr+= dstStride[0];
 
506
            srcPtr += srcStride[0];
 
507
            dstPtr += dstStride[0];
410
508
        }
411
509
    }
412
510
    return srcSliceH;
413
511
}
414
512
 
415
 
static int planarCopyWrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
416
 
                             int srcSliceH, uint8_t* dst[], int dstStride[])
 
513
#define clip9(x)  av_clip_uintp2(x,  9)
 
514
#define clip10(x) av_clip_uintp2(x, 10)
 
515
#define DITHER_COPY(dst, dstStride, wfunc, src, srcStride, rfunc, dithers, shift, clip) \
 
516
    for (i = 0; i < height; i++) { \
 
517
        const uint8_t *dither = dithers[i & 7]; \
 
518
        for (j = 0; j < length - 7; j += 8) { \
 
519
            wfunc(&dst[j + 0], clip((rfunc(&src[j + 0]) + dither[0]) >> shift)); \
 
520
            wfunc(&dst[j + 1], clip((rfunc(&src[j + 1]) + dither[1]) >> shift)); \
 
521
            wfunc(&dst[j + 2], clip((rfunc(&src[j + 2]) + dither[2]) >> shift)); \
 
522
            wfunc(&dst[j + 3], clip((rfunc(&src[j + 3]) + dither[3]) >> shift)); \
 
523
            wfunc(&dst[j + 4], clip((rfunc(&src[j + 4]) + dither[4]) >> shift)); \
 
524
            wfunc(&dst[j + 5], clip((rfunc(&src[j + 5]) + dither[5]) >> shift)); \
 
525
            wfunc(&dst[j + 6], clip((rfunc(&src[j + 6]) + dither[6]) >> shift)); \
 
526
            wfunc(&dst[j + 7], clip((rfunc(&src[j + 7]) + dither[7]) >> shift)); \
 
527
        } \
 
528
        for (; j < length; j++) \
 
529
            wfunc(&dst[j],     (rfunc(&src[j]) + dither[j & 7]) >> shift); \
 
530
        dst += dstStride; \
 
531
        src += srcStride; \
 
532
    }
 
533
 
 
534
static int planarCopyWrapper(SwsContext *c, const uint8_t *src[],
 
535
                             int srcStride[], int srcSliceY, int srcSliceH,
 
536
                             uint8_t *dst[], int dstStride[])
417
537
{
418
538
    int plane, i, j;
419
 
    for (plane=0; plane<4; plane++) {
420
 
        int length= (plane==0 || plane==3) ? c->srcW  : -((-c->srcW  )>>c->chrDstHSubSample);
421
 
        int y=      (plane==0 || plane==3) ? srcSliceY: -((-srcSliceY)>>c->chrDstVSubSample);
422
 
        int height= (plane==0 || plane==3) ? srcSliceH: -((-srcSliceH)>>c->chrDstVSubSample);
423
 
        const uint8_t *srcPtr= src[plane];
424
 
        uint8_t *dstPtr= dst[plane] + dstStride[plane]*y;
 
539
    for (plane = 0; plane < 4; plane++) {
 
540
        int length = (plane == 0 || plane == 3) ? c->srcW  : -((-c->srcW  ) >> c->chrDstHSubSample);
 
541
        int y =      (plane == 0 || plane == 3) ? srcSliceY: -((-srcSliceY) >> c->chrDstVSubSample);
 
542
        int height = (plane == 0 || plane == 3) ? srcSliceH: -((-srcSliceH) >> c->chrDstVSubSample);
 
543
        const uint8_t *srcPtr = src[plane];
 
544
        uint8_t *dstPtr = dst[plane] + dstStride[plane] * y;
425
545
 
426
 
        if (!dst[plane]) continue;
 
546
        if (!dst[plane])
 
547
            continue;
427
548
        // ignore palette for GRAY8
428
549
        if (plane == 1 && !dst[2]) continue;
429
550
        if (!src[plane] || (plane == 1 && !src[2])) {
430
 
            if(is16BPS(c->dstFormat))
431
 
                length*=2;
432
 
            fillPlane(dst[plane], dstStride[plane], length, height, y, (plane==3) ? 255 : 128);
 
551
            if (is16BPS(c->dstFormat))
 
552
                length *= 2;
 
553
            fillPlane(dst[plane], dstStride[plane], length, height, y,
 
554
                      (plane == 3) ? 255 : 128);
433
555
        } else {
434
 
            if(is9_OR_10BPS(c->srcFormat)) {
435
 
                const int src_depth = av_pix_fmt_descriptors[c->srcFormat].comp[plane].depth_minus1+1;
436
 
                const int dst_depth = av_pix_fmt_descriptors[c->dstFormat].comp[plane].depth_minus1+1;
437
 
                const uint16_t *srcPtr2 = (const uint16_t*)srcPtr;
 
556
            if (is9_OR_10BPS(c->srcFormat)) {
 
557
                const int src_depth = av_pix_fmt_descriptors[c->srcFormat].comp[plane].depth_minus1 + 1;
 
558
                const int dst_depth = av_pix_fmt_descriptors[c->dstFormat].comp[plane].depth_minus1 + 1;
 
559
                const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
438
560
 
439
561
                if (is16BPS(c->dstFormat)) {
440
 
                    uint16_t *dstPtr2 = (uint16_t*)dstPtr;
 
562
                    uint16_t *dstPtr2 = (uint16_t *) dstPtr;
441
563
#define COPY9_OR_10TO16(rfunc, wfunc) \
442
564
                    for (i = 0; i < height; i++) { \
443
565
                        for (j = 0; j < length; j++) { \
444
566
                            int srcpx = rfunc(&srcPtr2[j]); \
445
 
                            wfunc(&dstPtr2[j], (srcpx<<(16-src_depth)) | (srcpx>>(2*src_depth-16))); \
 
567
                            wfunc(&dstPtr2[j], (srcpx << (16 - src_depth)) | (srcpx >> (2 * src_depth - 16))); \
446
568
                        } \
447
 
                        dstPtr2 += dstStride[plane]/2; \
448
 
                        srcPtr2 += srcStride[plane]/2; \
 
569
                        dstPtr2 += dstStride[plane] / 2; \
 
570
                        srcPtr2 += srcStride[plane] / 2; \
449
571
                    }
450
572
                    if (isBE(c->dstFormat)) {
451
573
                        if (isBE(c->srcFormat)) {
461
583
                        }
462
584
                    }
463
585
                } else if (is9_OR_10BPS(c->dstFormat)) {
464
 
                    uint16_t *dstPtr2 = (uint16_t*)dstPtr;
 
586
                    uint16_t *dstPtr2 = (uint16_t *) dstPtr;
465
587
#define COPY9_OR_10TO9_OR_10(loop) \
466
588
                    for (i = 0; i < height; i++) { \
467
589
                        for (j = 0; j < length; j++) { \
468
590
                            loop; \
469
591
                        } \
470
 
                        dstPtr2 += dstStride[plane]/2; \
471
 
                        srcPtr2 += srcStride[plane]/2; \
 
592
                        dstPtr2 += dstStride[plane] / 2; \
 
593
                        srcPtr2 += srcStride[plane] / 2; \
472
594
                    }
473
595
#define COPY9_OR_10TO9_OR_10_2(rfunc, wfunc) \
474
596
                    if (dst_depth > src_depth) { \
475
597
                        COPY9_OR_10TO9_OR_10(int srcpx = rfunc(&srcPtr2[j]); \
476
598
                            wfunc(&dstPtr2[j], (srcpx << 1) | (srcpx >> 9))); \
477
599
                    } else if (dst_depth < src_depth) { \
478
 
                        COPY9_OR_10TO9_OR_10(wfunc(&dstPtr2[j], rfunc(&srcPtr2[j]) >> 1)); \
 
600
                        DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
 
601
                                    srcPtr2, srcStride[plane] / 2, rfunc, \
 
602
                                    dither_8x8_1, 1, clip9); \
479
603
                    } else { \
480
604
                        COPY9_OR_10TO9_OR_10(wfunc(&dstPtr2[j], rfunc(&srcPtr2[j]))); \
481
605
                    }
493
617
                        }
494
618
                    }
495
619
                } else {
496
 
                    // FIXME Maybe dither instead.
 
620
#define W8(a, b) { *(a) = (b); }
497
621
#define COPY9_OR_10TO8(rfunc) \
498
 
                    for (i = 0; i < height; i++) { \
499
 
                        for (j = 0; j < length; j++) { \
500
 
                            dstPtr[j] = rfunc(&srcPtr2[j])>>(src_depth-8); \
501
 
                        } \
502
 
                        dstPtr  += dstStride[plane]; \
503
 
                        srcPtr2 += srcStride[plane]/2; \
 
622
                    if (src_depth == 9) { \
 
623
                        DITHER_COPY(dstPtr,  dstStride[plane],   W8, \
 
624
                                    srcPtr2, srcStride[plane] / 2, rfunc, \
 
625
                                    dither_8x8_1, 1, av_clip_uint8); \
 
626
                    } else { \
 
627
                        DITHER_COPY(dstPtr,  dstStride[plane],   W8, \
 
628
                                    srcPtr2, srcStride[plane] / 2, rfunc, \
 
629
                                    dither_8x8_3, 2, av_clip_uint8); \
504
630
                    }
505
631
                    if (isBE(c->srcFormat)) {
506
632
                        COPY9_OR_10TO8(AV_RB16);
508
634
                        COPY9_OR_10TO8(AV_RL16);
509
635
                    }
510
636
                }
511
 
            } else if(is9_OR_10BPS(c->dstFormat)) {
512
 
                const int dst_depth = av_pix_fmt_descriptors[c->dstFormat].comp[plane].depth_minus1+1;
513
 
                uint16_t *dstPtr2 = (uint16_t*)dstPtr;
 
637
            } else if (is9_OR_10BPS(c->dstFormat)) {
 
638
                const int dst_depth = av_pix_fmt_descriptors[c->dstFormat].comp[plane].depth_minus1 + 1;
 
639
                uint16_t *dstPtr2 = (uint16_t *) dstPtr;
514
640
 
515
641
                if (is16BPS(c->srcFormat)) {
516
 
                    const uint16_t *srcPtr2 = (const uint16_t*)srcPtr;
 
642
                    const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
517
643
#define COPY16TO9_OR_10(rfunc, wfunc) \
518
 
                    for (i = 0; i < height; i++) { \
519
 
                        for (j = 0; j < length; j++) { \
520
 
                            wfunc(&dstPtr2[j], rfunc(&srcPtr2[j])>>(16-dst_depth)); \
521
 
                        } \
522
 
                        dstPtr2 += dstStride[plane]/2; \
523
 
                        srcPtr2 += srcStride[plane]/2; \
 
644
                    if (dst_depth == 9) { \
 
645
                        DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
 
646
                                    srcPtr2, srcStride[plane] / 2, rfunc, \
 
647
                                    dither_8x8_128, 7, clip9); \
 
648
                    } else { \
 
649
                        DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
 
650
                                    srcPtr2, srcStride[plane] / 2, rfunc, \
 
651
                                    dither_8x8_64, 6, clip10); \
524
652
                    }
525
653
                    if (isBE(c->dstFormat)) {
526
654
                        if (isBE(c->srcFormat)) {
540
668
                    for (i = 0; i < height; i++) { \
541
669
                        for (j = 0; j < length; j++) { \
542
670
                            const int srcpx = srcPtr[j]; \
543
 
                            wfunc(&dstPtr2[j], (srcpx<<(dst_depth-8)) | (srcpx >> (16-dst_depth))); \
 
671
                            wfunc(&dstPtr2[j], (srcpx << (dst_depth - 8)) | (srcpx >> (16 - dst_depth))); \
544
672
                        } \
545
 
                        dstPtr2 += dstStride[plane]/2; \
 
673
                        dstPtr2 += dstStride[plane] / 2; \
546
674
                        srcPtr  += srcStride[plane]; \
547
675
                    }
548
676
                    if (isBE(c->dstFormat)) {
551
679
                        COPY8TO9_OR_10(AV_WL16);
552
680
                    }
553
681
                }
554
 
            } else if(is16BPS(c->srcFormat) && !is16BPS(c->dstFormat)) {
555
 
                if (!isBE(c->srcFormat)) srcPtr++;
556
 
                for (i=0; i<height; i++) {
557
 
                    for (j=0; j<length; j++) dstPtr[j] = srcPtr[j<<1];
558
 
                    srcPtr+= srcStride[plane];
559
 
                    dstPtr+= dstStride[plane];
 
682
            } else if (is16BPS(c->srcFormat) && !is16BPS(c->dstFormat)) {
 
683
                const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
 
684
#define COPY16TO8(rfunc) \
 
685
                    DITHER_COPY(dstPtr,  dstStride[plane],   W8, \
 
686
                                srcPtr2, srcStride[plane] / 2, rfunc, \
 
687
                                dither_8x8_256, 8, av_clip_uint8);
 
688
                if (isBE(c->srcFormat)) {
 
689
                    COPY16TO8(AV_RB16);
 
690
                } else {
 
691
                    COPY16TO8(AV_RL16);
560
692
                }
561
 
            } else if(!is16BPS(c->srcFormat) && is16BPS(c->dstFormat)) {
562
 
                for (i=0; i<height; i++) {
563
 
                    for (j=0; j<length; j++) {
564
 
                        dstPtr[ j<<1   ] = srcPtr[j];
565
 
                        dstPtr[(j<<1)+1] = srcPtr[j];
 
693
            } else if (!is16BPS(c->srcFormat) && is16BPS(c->dstFormat)) {
 
694
                for (i = 0; i < height; i++) {
 
695
                    for (j = 0; j < length; j++) {
 
696
                        dstPtr[ j << 1     ] = srcPtr[j];
 
697
                        dstPtr[(j << 1) + 1] = srcPtr[j];
566
698
                    }
567
 
                    srcPtr+= srcStride[plane];
568
 
                    dstPtr+= dstStride[plane];
 
699
                    srcPtr += srcStride[plane];
 
700
                    dstPtr += dstStride[plane];
569
701
                }
570
 
            } else if(is16BPS(c->srcFormat) && is16BPS(c->dstFormat)
571
 
                  && isBE(c->srcFormat) != isBE(c->dstFormat)) {
 
702
            } else if (is16BPS(c->srcFormat) && is16BPS(c->dstFormat) &&
 
703
                      isBE(c->srcFormat) != isBE(c->dstFormat)) {
572
704
 
573
 
                for (i=0; i<height; i++) {
574
 
                    for (j=0; j<length; j++)
575
 
                        ((uint16_t*)dstPtr)[j] = av_bswap16(((const uint16_t*)srcPtr)[j]);
576
 
                    srcPtr+= srcStride[plane];
577
 
                    dstPtr+= dstStride[plane];
 
705
                for (i = 0; i < height; i++) {
 
706
                    for (j = 0; j < length; j++)
 
707
                        ((uint16_t *) dstPtr)[j] = av_bswap16(((const uint16_t *) srcPtr)[j]);
 
708
                    srcPtr += srcStride[plane];
 
709
                    dstPtr += dstStride[plane];
578
710
                }
579
711
            } else if (dstStride[plane] == srcStride[plane] &&
580
712
                       srcStride[plane] > 0 && srcStride[plane] == length) {
581
 
                memcpy(dst[plane] + dstStride[plane]*y, src[plane],
582
 
                       height*dstStride[plane]);
 
713
                memcpy(dst[plane] + dstStride[plane] * y, src[plane],
 
714
                       height * dstStride[plane]);
583
715
            } else {
584
 
                if(is16BPS(c->srcFormat) && is16BPS(c->dstFormat))
585
 
                    length*=2;
586
 
                for (i=0; i<height; i++) {
 
716
                if (is16BPS(c->srcFormat) && is16BPS(c->dstFormat))
 
717
                    length *= 2;
 
718
                for (i = 0; i < height; i++) {
587
719
                    memcpy(dstPtr, srcPtr, length);
588
 
                    srcPtr+= srcStride[plane];
589
 
                    dstPtr+= dstStride[plane];
 
720
                    srcPtr += srcStride[plane];
 
721
                    dstPtr += dstStride[plane];
590
722
                }
591
723
            }
592
724
        }
594
726
    return srcSliceH;
595
727
}
596
728
 
 
729
 
 
730
#define IS_DIFFERENT_ENDIANESS(src_fmt, dst_fmt, pix_fmt)          \
 
731
    ((src_fmt == pix_fmt ## BE && dst_fmt == pix_fmt ## LE) ||     \
 
732
     (src_fmt == pix_fmt ## LE && dst_fmt == pix_fmt ## BE))
 
733
 
 
734
 
597
735
void ff_get_unscaled_swscale(SwsContext *c)
598
736
{
599
737
    const enum PixelFormat srcFormat = c->srcFormat;
602
740
    const int dstH = c->dstH;
603
741
    int needsDither;
604
742
 
605
 
    needsDither= isAnyRGB(dstFormat)
606
 
        &&  c->dstFormatBpp < 24
607
 
        && (c->dstFormatBpp < c->srcFormatBpp || (!isAnyRGB(srcFormat)));
 
743
    needsDither = isAnyRGB(dstFormat) &&
 
744
            c->dstFormatBpp < 24 &&
 
745
           (c->dstFormatBpp < c->srcFormatBpp || (!isAnyRGB(srcFormat)));
608
746
 
609
747
    /* yv12_to_nv12 */
610
 
    if ((srcFormat == PIX_FMT_YUV420P || srcFormat == PIX_FMT_YUVA420P) && (dstFormat == PIX_FMT_NV12 || dstFormat == PIX_FMT_NV21)) {
611
 
        c->swScale= planarToNv12Wrapper;
 
748
    if ((srcFormat == PIX_FMT_YUV420P || srcFormat == PIX_FMT_YUVA420P) &&
 
749
        (dstFormat == PIX_FMT_NV12 || dstFormat == PIX_FMT_NV21)) {
 
750
        c->swScale = planarToNv12Wrapper;
612
751
    }
613
752
    /* yuv2bgr */
614
 
    if ((srcFormat==PIX_FMT_YUV420P || srcFormat==PIX_FMT_YUV422P || srcFormat==PIX_FMT_YUVA420P) && isAnyRGB(dstFormat)
615
 
        && !(flags & SWS_ACCURATE_RND) && !(dstH&1)) {
616
 
        c->swScale= ff_yuv2rgb_get_func_ptr(c);
 
753
    if ((srcFormat == PIX_FMT_YUV420P || srcFormat == PIX_FMT_YUV422P ||
 
754
         srcFormat == PIX_FMT_YUVA420P) && isAnyRGB(dstFormat) &&
 
755
        !(flags & SWS_ACCURATE_RND) && !(dstH & 1)) {
 
756
        c->swScale = ff_yuv2rgb_get_func_ptr(c);
617
757
    }
618
758
 
619
 
    if (srcFormat==PIX_FMT_YUV410P && (dstFormat==PIX_FMT_YUV420P || dstFormat==PIX_FMT_YUVA420P) && !(flags & SWS_BITEXACT)) {
620
 
        c->swScale= yvu9ToYv12Wrapper;
 
759
    if (srcFormat == PIX_FMT_YUV410P &&
 
760
        (dstFormat == PIX_FMT_YUV420P || dstFormat == PIX_FMT_YUVA420P) &&
 
761
        !(flags & SWS_BITEXACT)) {
 
762
        c->swScale = yvu9ToYv12Wrapper;
621
763
    }
622
764
 
623
765
    /* bgr24toYV12 */
624
 
    if (srcFormat==PIX_FMT_BGR24 && (dstFormat==PIX_FMT_YUV420P || dstFormat==PIX_FMT_YUVA420P) && !(flags & SWS_ACCURATE_RND))
625
 
        c->swScale= bgr24ToYv12Wrapper;
 
766
    if (srcFormat == PIX_FMT_BGR24 &&
 
767
        (dstFormat == PIX_FMT_YUV420P || dstFormat == PIX_FMT_YUVA420P) &&
 
768
        !(flags & SWS_ACCURATE_RND))
 
769
        c->swScale = bgr24ToYv12Wrapper;
626
770
 
627
771
    /* RGB/BGR -> RGB/BGR (no dither needed forms) */
628
772
    if (   isAnyRGB(srcFormat)
642
786
        && (!needsDither || (c->flags&(SWS_FAST_BILINEAR|SWS_POINT))))
643
787
        c->swScale= rgbToRgbWrapper;
644
788
 
 
789
    /* bswap 16 bits per pixel/component packed formats */
 
790
    if (IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, PIX_FMT_BGR444) ||
 
791
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, PIX_FMT_BGR48)  ||
 
792
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, PIX_FMT_BGR555) ||
 
793
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, PIX_FMT_BGR565) ||
 
794
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, PIX_FMT_GRAY16) ||
 
795
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, PIX_FMT_RGB444) ||
 
796
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, PIX_FMT_RGB48)  ||
 
797
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, PIX_FMT_RGB555) ||
 
798
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, PIX_FMT_RGB565))
 
799
        c->swScale = packed_16bpc_bswap;
 
800
 
645
801
    if ((usePal(srcFormat) && (
646
802
        dstFormat == PIX_FMT_RGB32   ||
647
803
        dstFormat == PIX_FMT_RGB32_1 ||
649
805
        dstFormat == PIX_FMT_BGR32   ||
650
806
        dstFormat == PIX_FMT_BGR32_1 ||
651
807
        dstFormat == PIX_FMT_BGR24)))
652
 
        c->swScale= palToRgbWrapper;
 
808
        c->swScale = palToRgbWrapper;
653
809
 
654
810
    if (srcFormat == PIX_FMT_YUV422P) {
655
811
        if (dstFormat == PIX_FMT_YUYV422)
656
 
            c->swScale= yuv422pToYuy2Wrapper;
 
812
            c->swScale = yuv422pToYuy2Wrapper;
657
813
        else if (dstFormat == PIX_FMT_UYVY422)
658
 
            c->swScale= yuv422pToUyvyWrapper;
 
814
            c->swScale = yuv422pToUyvyWrapper;
659
815
    }
660
816
 
661
817
    /* LQ converters if -sws 0 or -sws 4*/
663
819
        /* yv12_to_yuy2 */
664
820
        if (srcFormat == PIX_FMT_YUV420P || srcFormat == PIX_FMT_YUVA420P) {
665
821
            if (dstFormat == PIX_FMT_YUYV422)
666
 
                c->swScale= planarToYuy2Wrapper;
 
822
                c->swScale = planarToYuy2Wrapper;
667
823
            else if (dstFormat == PIX_FMT_UYVY422)
668
 
                c->swScale= planarToUyvyWrapper;
 
824
                c->swScale = planarToUyvyWrapper;
669
825
        }
670
826
    }
671
 
    if(srcFormat == PIX_FMT_YUYV422 && (dstFormat == PIX_FMT_YUV420P || dstFormat == PIX_FMT_YUVA420P))
672
 
        c->swScale= yuyvToYuv420Wrapper;
673
 
    if(srcFormat == PIX_FMT_UYVY422 && (dstFormat == PIX_FMT_YUV420P || dstFormat == PIX_FMT_YUVA420P))
674
 
        c->swScale= uyvyToYuv420Wrapper;
675
 
    if(srcFormat == PIX_FMT_YUYV422 && dstFormat == PIX_FMT_YUV422P)
676
 
        c->swScale= yuyvToYuv422Wrapper;
677
 
    if(srcFormat == PIX_FMT_UYVY422 && dstFormat == PIX_FMT_YUV422P)
678
 
        c->swScale= uyvyToYuv422Wrapper;
 
827
    if (srcFormat == PIX_FMT_YUYV422 &&
 
828
       (dstFormat == PIX_FMT_YUV420P || dstFormat == PIX_FMT_YUVA420P))
 
829
        c->swScale = yuyvToYuv420Wrapper;
 
830
    if (srcFormat == PIX_FMT_UYVY422 &&
 
831
       (dstFormat == PIX_FMT_YUV420P || dstFormat == PIX_FMT_YUVA420P))
 
832
        c->swScale = uyvyToYuv420Wrapper;
 
833
    if (srcFormat == PIX_FMT_YUYV422 && dstFormat == PIX_FMT_YUV422P)
 
834
        c->swScale = yuyvToYuv422Wrapper;
 
835
    if (srcFormat == PIX_FMT_UYVY422 && dstFormat == PIX_FMT_YUV422P)
 
836
        c->swScale = uyvyToYuv422Wrapper;
679
837
 
680
838
    /* simple copy */
681
 
    if (  srcFormat == dstFormat
682
 
        || (srcFormat == PIX_FMT_YUVA420P && dstFormat == PIX_FMT_YUV420P)
683
 
        || (srcFormat == PIX_FMT_YUV420P && dstFormat == PIX_FMT_YUVA420P)
684
 
        || (isPlanarYUV(srcFormat) && isGray(dstFormat))
685
 
        || (isPlanarYUV(dstFormat) && isGray(srcFormat))
686
 
        || (isGray(dstFormat) && isGray(srcFormat))
687
 
        || (isPlanarYUV(srcFormat) && isPlanarYUV(dstFormat)
688
 
            && c->chrDstHSubSample == c->chrSrcHSubSample
689
 
            && c->chrDstVSubSample == c->chrSrcVSubSample
690
 
            && dstFormat != PIX_FMT_NV12 && dstFormat != PIX_FMT_NV21
691
 
            && srcFormat != PIX_FMT_NV12 && srcFormat != PIX_FMT_NV21))
 
839
    if ( srcFormat == dstFormat ||
 
840
        (srcFormat == PIX_FMT_YUVA420P && dstFormat == PIX_FMT_YUV420P) ||
 
841
        (srcFormat == PIX_FMT_YUV420P && dstFormat == PIX_FMT_YUVA420P) ||
 
842
        (isPlanarYUV(srcFormat) && isGray(dstFormat)) ||
 
843
        (isPlanarYUV(dstFormat) && isGray(srcFormat)) ||
 
844
        (isGray(dstFormat) && isGray(srcFormat)) ||
 
845
        (isPlanarYUV(srcFormat) && isPlanarYUV(dstFormat) &&
 
846
         c->chrDstHSubSample == c->chrSrcHSubSample &&
 
847
         c->chrDstVSubSample == c->chrSrcVSubSample &&
 
848
         dstFormat != PIX_FMT_NV12 && dstFormat != PIX_FMT_NV21 &&
 
849
         srcFormat != PIX_FMT_NV12 && srcFormat != PIX_FMT_NV21))
692
850
    {
693
851
        if (isPacked(c->srcFormat))
694
 
            c->swScale= packedCopyWrapper;
 
852
            c->swScale = packedCopyWrapper;
695
853
        else /* Planar YUV or gray */
696
 
            c->swScale= planarCopyWrapper;
 
854
            c->swScale = planarCopyWrapper;
697
855
    }
698
856
 
699
857
    if (ARCH_BFIN)
702
860
        ff_swscale_get_unscaled_altivec(c);
703
861
}
704
862
 
705
 
static void reset_ptr(const uint8_t* src[], int format)
 
863
static void reset_ptr(const uint8_t *src[], int format)
706
864
{
707
 
    if(!isALPHA(format))
708
 
        src[3]=NULL;
709
 
    if(!isPlanarYUV(format)) {
710
 
        src[3]=src[2]=NULL;
 
865
    if (!isALPHA(format))
 
866
        src[3] = NULL;
 
867
    if (!isPlanar(format)) {
 
868
        src[3] = src[2] = NULL;
711
869
 
712
870
        if (!usePal(format))
713
 
            src[1]= NULL;
 
871
            src[1] = NULL;
714
872
    }
715
873
}
716
874
 
733
891
 * swscale wrapper, so we don't need to export the SwsContext.
734
892
 * Assumes planar YUV to be in YUV order instead of YVU.
735
893
 */
736
 
int sws_scale(SwsContext *c, const uint8_t* const src[], const int srcStride[], int srcSliceY,
737
 
              int srcSliceH, uint8_t* const dst[], const int dstStride[])
 
894
int attribute_align_arg sws_scale(struct SwsContext *c,
 
895
                                  const uint8_t * const srcSlice[],
 
896
                                  const int srcStride[], int srcSliceY,
 
897
                                  int srcSliceH, uint8_t *const dst[],
 
898
                                  const int dstStride[])
738
899
{
739
900
    int i;
740
 
    const uint8_t* src2[4]= {src[0], src[1], src[2], src[3]};
741
 
    uint8_t* dst2[4]= {dst[0], dst[1], dst[2], dst[3]};
 
901
    const uint8_t *src2[4] = { srcSlice[0], srcSlice[1], srcSlice[2], srcSlice[3] };
 
902
    uint8_t *dst2[4] = { dst[0], dst[1], dst[2], dst[3] };
742
903
 
743
904
    // do not mess up sliceDir if we have a "trailing" 0-size slice
744
905
    if (srcSliceH == 0)
745
906
        return 0;
746
907
 
747
 
    if (!check_image_pointers(src, c->srcFormat, srcStride)) {
 
908
    if (!check_image_pointers(srcSlice, c->srcFormat, srcStride)) {
748
909
        av_log(c, AV_LOG_ERROR, "bad src image pointers\n");
749
910
        return 0;
750
911
    }
762
923
    }
763
924
 
764
925
    if (usePal(c->srcFormat)) {
765
 
        for (i=0; i<256; i++) {
766
 
            int p, r, g, b,y,u,v;
767
 
            if(c->srcFormat == PIX_FMT_PAL8) {
768
 
                p=((const uint32_t*)(src[1]))[i];
769
 
                r= (p>>16)&0xFF;
770
 
                g= (p>> 8)&0xFF;
771
 
                b=  p     &0xFF;
772
 
            } else if(c->srcFormat == PIX_FMT_RGB8) {
773
 
                r= (i>>5    )*36;
774
 
                g= ((i>>2)&7)*36;
775
 
                b= (i&3     )*85;
776
 
            } else if(c->srcFormat == PIX_FMT_BGR8) {
777
 
                b= (i>>6    )*85;
778
 
                g= ((i>>3)&7)*36;
779
 
                r= (i&7     )*36;
780
 
            } else if(c->srcFormat == PIX_FMT_RGB4_BYTE) {
781
 
                r= (i>>3    )*255;
782
 
                g= ((i>>1)&3)*85;
783
 
                b= (i&1     )*255;
784
 
            } else if(c->srcFormat == PIX_FMT_GRAY8 || c->srcFormat == PIX_FMT_Y400A) {
 
926
        for (i = 0; i < 256; i++) {
 
927
            int p, r, g, b, y, u, v;
 
928
            if (c->srcFormat == PIX_FMT_PAL8) {
 
929
                p = ((const uint32_t *)(srcSlice[1]))[i];
 
930
                r = (p >> 16) & 0xFF;
 
931
                g = (p >>  8) & 0xFF;
 
932
                b =  p        & 0xFF;
 
933
            } else if (c->srcFormat == PIX_FMT_RGB8) {
 
934
                r = ( i >> 5     ) * 36;
 
935
                g = ((i >> 2) & 7) * 36;
 
936
                b = ( i       & 3) * 85;
 
937
            } else if (c->srcFormat == PIX_FMT_BGR8) {
 
938
                b = ( i >> 6     ) * 85;
 
939
                g = ((i >> 3) & 7) * 36;
 
940
                r = ( i       & 7) * 36;
 
941
            } else if (c->srcFormat == PIX_FMT_RGB4_BYTE) {
 
942
                r = ( i >> 3     ) * 255;
 
943
                g = ((i >> 1) & 3) * 85;
 
944
                b = ( i       & 1) * 255;
 
945
            } else if (c->srcFormat == PIX_FMT_GRAY8 ||
 
946
                      c->srcFormat == PIX_FMT_Y400A) {
785
947
                r = g = b = i;
786
948
            } else {
787
949
                assert(c->srcFormat == PIX_FMT_BGR4_BYTE);
788
 
                b= (i>>3    )*255;
789
 
                g= ((i>>1)&3)*85;
790
 
                r= (i&1     )*255;
 
950
                b = ( i >> 3     ) * 255;
 
951
                g = ((i >> 1) & 3) * 85;
 
952
                r = ( i       & 1) * 255;
791
953
            }
792
 
            y= av_clip_uint8((RY*r + GY*g + BY*b + ( 33<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT);
793
 
            u= av_clip_uint8((RU*r + GU*g + BU*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT);
794
 
            v= av_clip_uint8((RV*r + GV*g + BV*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT);
795
 
            c->pal_yuv[i]= y + (u<<8) + (v<<16);
 
954
            y = av_clip_uint8((RY * r + GY * g + BY * b + ( 33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
 
955
            u = av_clip_uint8((RU * r + GU * g + BU * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
 
956
            v = av_clip_uint8((RV * r + GV * g + BV * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
 
957
            c->pal_yuv[i] = y + (u << 8) + (v << 16);
796
958
 
797
 
            switch(c->dstFormat) {
 
959
            switch (c->dstFormat) {
798
960
            case PIX_FMT_BGR32:
799
961
#if !HAVE_BIGENDIAN
800
962
            case PIX_FMT_RGB24:
801
963
#endif
802
 
                c->pal_rgb[i]=  r + (g<<8) + (b<<16);
 
964
                c->pal_rgb[i] =  r + (g << 8) + (b << 16);
803
965
                break;
804
966
            case PIX_FMT_BGR32_1:
805
967
#if HAVE_BIGENDIAN
806
968
            case PIX_FMT_BGR24:
807
969
#endif
808
 
                c->pal_rgb[i]= (r + (g<<8) + (b<<16)) << 8;
 
970
                c->pal_rgb[i] = (r + (g << 8) + (b << 16)) << 8;
809
971
                break;
810
972
            case PIX_FMT_RGB32_1:
811
973
#if HAVE_BIGENDIAN
812
974
            case PIX_FMT_RGB24:
813
975
#endif
814
 
                c->pal_rgb[i]= (b + (g<<8) + (r<<16)) << 8;
 
976
                c->pal_rgb[i] = (b + (g << 8) + (r << 16)) << 8;
815
977
                break;
816
978
            case PIX_FMT_RGB32:
817
979
#if !HAVE_BIGENDIAN
818
980
            case PIX_FMT_BGR24:
819
981
#endif
820
982
            default:
821
 
                c->pal_rgb[i]=  b + (g<<8) + (r<<16);
 
983
                c->pal_rgb[i] =  b + (g << 8) + (r << 16);
822
984
            }
823
985
        }
824
986
    }
826
988
    // copy strides, so they can safely be modified
827
989
    if (c->sliceDir == 1) {
828
990
        // slices go from top to bottom
829
 
        int srcStride2[4]= {srcStride[0], srcStride[1], srcStride[2], srcStride[3]};
830
 
        int dstStride2[4]= {dstStride[0], dstStride[1], dstStride[2], dstStride[3]};
 
991
        int srcStride2[4] = { srcStride[0], srcStride[1], srcStride[2],
 
992
                              srcStride[3] };
 
993
        int dstStride2[4] = { dstStride[0], dstStride[1], dstStride[2],
 
994
                              dstStride[3] };
831
995
 
832
996
        reset_ptr(src2, c->srcFormat);
833
 
        reset_ptr((const uint8_t**)dst2, c->dstFormat);
 
997
        reset_ptr((const uint8_t **) dst2, c->dstFormat);
834
998
 
835
999
        /* reset slice direction at end of frame */
836
1000
        if (srcSliceY + srcSliceH == c->srcH)
837
1001
            c->sliceDir = 0;
838
1002
 
839
 
        return c->swScale(c, src2, srcStride2, srcSliceY, srcSliceH, dst2, dstStride2);
 
1003
        return c->swScale(c, src2, srcStride2, srcSliceY, srcSliceH, dst2,
 
1004
                          dstStride2);
840
1005
    } else {
841
1006
        // slices go from bottom to top => we flip the image internally
842
 
        int srcStride2[4]= {-srcStride[0], -srcStride[1], -srcStride[2], -srcStride[3]};
843
 
        int dstStride2[4]= {-dstStride[0], -dstStride[1], -dstStride[2], -dstStride[3]};
 
1007
        int srcStride2[4] = { -srcStride[0], -srcStride[1], -srcStride[2],
 
1008
                              -srcStride[3] };
 
1009
        int dstStride2[4] = { -dstStride[0], -dstStride[1], -dstStride[2],
 
1010
                              -dstStride[3] };
844
1011
 
845
 
        src2[0] += (srcSliceH-1)*srcStride[0];
 
1012
        src2[0] += (srcSliceH - 1) * srcStride[0];
846
1013
        if (!usePal(c->srcFormat))
847
 
            src2[1] += ((srcSliceH>>c->chrSrcVSubSample)-1)*srcStride[1];
848
 
        src2[2] += ((srcSliceH>>c->chrSrcVSubSample)-1)*srcStride[2];
849
 
        src2[3] += (srcSliceH-1)*srcStride[3];
850
 
        dst2[0] += ( c->dstH                      -1)*dstStride[0];
851
 
        dst2[1] += ((c->dstH>>c->chrDstVSubSample)-1)*dstStride[1];
852
 
        dst2[2] += ((c->dstH>>c->chrDstVSubSample)-1)*dstStride[2];
853
 
        dst2[3] += ( c->dstH                      -1)*dstStride[3];
 
1014
            src2[1] += ((srcSliceH >> c->chrSrcVSubSample) - 1) * srcStride[1];
 
1015
        src2[2] += ((srcSliceH >> c->chrSrcVSubSample) - 1) * srcStride[2];
 
1016
        src2[3] += (srcSliceH - 1) * srcStride[3];
 
1017
        dst2[0] += ( c->dstH                         - 1) * dstStride[0];
 
1018
        dst2[1] += ((c->dstH >> c->chrDstVSubSample) - 1) * dstStride[1];
 
1019
        dst2[2] += ((c->dstH >> c->chrDstVSubSample) - 1) * dstStride[2];
 
1020
        dst2[3] += ( c->dstH                         - 1) * dstStride[3];
854
1021
 
855
1022
        reset_ptr(src2, c->srcFormat);
856
 
        reset_ptr((const uint8_t**)dst2, c->dstFormat);
 
1023
        reset_ptr((const uint8_t **) dst2, c->dstFormat);
857
1024
 
858
1025
        /* reset slice direction at end of frame */
859
1026
        if (!srcSliceY)
860
1027
            c->sliceDir = 0;
861
1028
 
862
 
        return c->swScale(c, src2, srcStride2, c->srcH-srcSliceY-srcSliceH, srcSliceH, dst2, dstStride2);
 
1029
        return c->swScale(c, src2, srcStride2, c->srcH-srcSliceY-srcSliceH,
 
1030
                          srcSliceH, dst2, dstStride2);
863
1031
    }
864
1032
}
865
1033
 
866
1034
/* Convert the palette to the same packed 32-bit format as the palette */
867
 
void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
 
1035
void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst,
 
1036
                                   int num_pixels, const uint8_t *palette)
868
1037
{
869
1038
    int i;
870
1039
 
871
 
    for (i=0; i<num_pixels; i++)
 
1040
    for (i = 0; i < num_pixels; i++)
872
1041
        ((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i]];
873
1042
}
874
1043
 
875
1044
/* Palette format: ABCD -> dst format: ABC */
876
 
void sws_convertPalette8ToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
 
1045
void sws_convertPalette8ToPacked24(const uint8_t *src, uint8_t *dst,
 
1046
                                   int num_pixels, const uint8_t *palette)
877
1047
{
878
1048
    int i;
879
1049
 
880
 
    for (i=0; i<num_pixels; i++) {
 
1050
    for (i = 0; i < num_pixels; i++) {
881
1051
        //FIXME slow?
882
 
        dst[0]= palette[src[i]*4+0];
883
 
        dst[1]= palette[src[i]*4+1];
884
 
        dst[2]= palette[src[i]*4+2];
885
 
        dst+= 3;
 
1052
        dst[0] = palette[src[i] * 4 + 0];
 
1053
        dst[1] = palette[src[i] * 4 + 1];
 
1054
        dst[2] = palette[src[i] * 4 + 2];
 
1055
        dst += 3;
886
1056
    }
887
1057
}