This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_dx5yuv.c
309 lines (271 loc) · 8.97 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2006 Sam Lantinga
4
5
This library is free software; you can redistribute it and/or
6
modify it under the terms of the GNU Lesser General Public
7
License as published by the Free Software Foundation; either
8
version 2.1 of the License, or (at your option) any later version.
9
10
11
12
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
Lesser General Public License for more details.
14
15
16
17
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
25
/* This is the DirectDraw implementation of YUV video overlays */
26
#include "SDL_video.h"
27
#include "SDL_dx5yuv_c.h"
28
#include "../SDL_yuvfuncs.h"
29
30
//#define USE_DIRECTX_OVERLAY
31
32
33
/* The functions used to manipulate software video overlays */
static struct private_yuvhwfuncs dx5_yuvfuncs = {
34
35
36
37
DX5_LockYUVOverlay,
DX5_UnlockYUVOverlay,
DX5_DisplayYUVOverlay,
DX5_FreeYUVOverlay
38
39
};
40
41
42
struct private_yuvhwdata
{
LPDIRECTDRAWSURFACE3 surface;
43
44
45
46
/* These are just so we don't have to allocate them separately */
Uint16 pitches[3];
Uint8 *planes[3];
47
48
49
};
50
static LPDIRECTDRAWSURFACE3
51
CreateYUVSurface(_THIS, int width, int height, Uint32 format)
52
{
53
54
55
56
57
58
HRESULT result;
LPDIRECTDRAWSURFACE dd_surface1;
LPDIRECTDRAWSURFACE3 dd_surface3;
DDSURFACEDESC ddsd;
/* Set up the surface description */
59
60
SDL_memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
61
62
63
ddsd.dwFlags = (DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_PIXELFORMAT);
ddsd.dwWidth = width;
ddsd.dwHeight = height;
64
#ifdef USE_DIRECTX_OVERLAY
65
ddsd.ddsCaps.dwCaps = (DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY);
66
#else
67
ddsd.ddsCaps.dwCaps = (DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY);
68
#endif
69
ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
70
71
72
73
ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC;
ddsd.ddpfPixelFormat.dwFourCC = format;
/* Create the DirectDraw video surface */
74
result = IDirectDraw2_CreateSurface(ddraw2, &ddsd, &dd_surface1, NULL);
75
if (result != DD_OK) {
76
SetDDerror("DirectDraw2::CreateSurface", result);
77
78
return (NULL);
}
79
80
81
82
result = IDirectDrawSurface_QueryInterface(dd_surface1,
&IID_IDirectDrawSurface3,
(LPVOID *) & dd_surface3);
IDirectDrawSurface_Release(dd_surface1);
83
if (result != DD_OK) {
84
SetDDerror("DirectDrawSurface::QueryInterface", result);
85
86
87
88
return (NULL);
}
/* Make sure the surface format was set properly */
89
90
91
92
SDL_memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
result = IDirectDrawSurface3_Lock(dd_surface3, NULL,
&ddsd, DDLOCK_NOSYSLOCK, NULL);
93
if (result != DD_OK) {
94
95
SetDDerror("DirectDrawSurface3::Lock", result);
IDirectDrawSurface_Release(dd_surface3);
96
97
return (NULL);
}
98
IDirectDrawSurface3_Unlock(dd_surface3, NULL);
99
100
101
if (!(ddsd.ddpfPixelFormat.dwFlags & DDPF_FOURCC) ||
(ddsd.ddpfPixelFormat.dwFourCC != format)) {
102
103
SDL_SetError("DDraw didn't use requested FourCC format");
IDirectDrawSurface_Release(dd_surface3);
104
105
106
107
108
return (NULL);
}
/* We're ready to go! */
return (dd_surface3);
109
110
111
}
#ifdef DEBUG_YUV
112
static char *
113
PrintFOURCC(Uint32 code)
114
{
115
static char buf[5];
116
117
118
119
120
121
buf[3] = code >> 24;
buf[2] = (code >> 16) & 0xFF;
buf[1] = (code >> 8) & 0xFF;
buf[0] = (code & 0xFF);
return (buf);
122
123
124
}
#endif
125
SDL_Overlay *
126
127
DX5_CreateYUVOverlay(_THIS, int width, int height, Uint32 format,
SDL_Surface * display)
128
{
129
130
SDL_Overlay *overlay;
struct private_yuvhwdata *hwdata;
131
132
#ifdef DEBUG_YUV
133
134
135
DWORD numcodes;
DWORD *codes;
136
137
printf("FOURCC format requested: 0x%x\n", PrintFOURCC(format));
IDirectDraw2_GetFourCCCodes(ddraw2, &numcodes, NULL);
138
139
if (numcodes) {
DWORD i;
140
codes = SDL_malloc(numcodes * sizeof(*codes));
141
if (codes) {
142
IDirectDraw2_GetFourCCCodes(ddraw2, &numcodes, codes);
143
for (i = 0; i < numcodes; ++i) {
144
fprintf(stderr, "Code %d: 0x%x\n", i, PrintFOURCC(codes[i]));
145
}
146
SDL_free(codes);
147
148
}
} else {
149
fprintf(stderr, "No FOURCC codes supported\n");
150
}
151
152
#endif
153
/* Create the overlay structure */
154
overlay = (SDL_Overlay *) SDL_malloc(sizeof *overlay);
155
if (overlay == NULL) {
156
SDL_OutOfMemory();
157
158
return (NULL);
}
159
SDL_memset(overlay, 0, (sizeof *overlay));
160
161
162
163
164
165
166
167
168
169
/* Fill in the basic members */
overlay->format = format;
overlay->w = width;
overlay->h = height;
/* Set up the YUV surface function structure */
overlay->hwfuncs = &dx5_yuvfuncs;
/* Create the pixel data and lookup tables */
170
hwdata = (struct private_yuvhwdata *) SDL_malloc(sizeof *hwdata);
171
172
overlay->hwdata = hwdata;
if (hwdata == NULL) {
173
174
SDL_OutOfMemory();
SDL_FreeYUVOverlay(overlay);
175
176
return (NULL);
}
177
hwdata->surface = CreateYUVSurface(this, width, height, format);
178
if (hwdata->surface == NULL) {
179
SDL_FreeYUVOverlay(overlay);
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
return (NULL);
}
overlay->hw_overlay = 1;
/* Set up the plane pointers */
overlay->pitches = hwdata->pitches;
overlay->pixels = hwdata->planes;
switch (format) {
case SDL_YV12_OVERLAY:
case SDL_IYUV_OVERLAY:
overlay->planes = 3;
break;
default:
overlay->planes = 1;
break;
}
/* We're all done.. */
return (overlay);
199
200
}
201
int
202
DX5_LockYUVOverlay(_THIS, SDL_Overlay * overlay)
203
{
204
205
206
207
208
HRESULT result;
LPDIRECTDRAWSURFACE3 surface;
DDSURFACEDESC ddsd;
surface = overlay->hwdata->surface;
209
210
211
212
SDL_memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
result = IDirectDrawSurface3_Lock(surface, NULL,
&ddsd, DDLOCK_NOSYSLOCK, NULL);
213
if (result == DDERR_SURFACELOST) {
214
215
216
217
result = IDirectDrawSurface3_Restore(surface);
result = IDirectDrawSurface3_Lock(surface, NULL, &ddsd,
(DDLOCK_NOSYSLOCK | DDLOCK_WAIT),
NULL);
218
219
}
if (result != DD_OK) {
220
SetDDerror("DirectDrawSurface3::Lock", result);
221
222
223
224
return (-1);
}
/* Find the pitch and offset values for the overlay */
225
#if defined(NONAMELESSUNION)
226
overlay->pitches[0] = (Uint16) ddsd.u1.lPitch;
227
#else
228
overlay->pitches[0] = (Uint16) ddsd.lPitch;
229
#endif
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
overlay->pixels[0] = (Uint8 *) ddsd.lpSurface;
switch (overlay->format) {
case SDL_YV12_OVERLAY:
case SDL_IYUV_OVERLAY:
/* Add the two extra planes */
overlay->pitches[1] = overlay->pitches[0] / 2;
overlay->pitches[2] = overlay->pitches[0] / 2;
overlay->pixels[1] = overlay->pixels[0] +
overlay->pitches[0] * overlay->h;
overlay->pixels[2] = overlay->pixels[1] +
overlay->pitches[1] * overlay->h / 2;
break;
default:
/* Only one plane, no worries */
break;
}
return (0);
247
248
}
249
void
250
DX5_UnlockYUVOverlay(_THIS, SDL_Overlay * overlay)
251
{
252
LPDIRECTDRAWSURFACE3 surface;
253
254
surface = overlay->hwdata->surface;
255
IDirectDrawSurface3_Unlock(surface, NULL);
256
257
}
258
int
259
260
DX5_DisplayYUVOverlay(_THIS, SDL_Overlay * overlay, SDL_Rect * src,
SDL_Rect * dst)
261
{
262
263
264
265
266
267
268
269
270
271
272
273
274
HRESULT result;
LPDIRECTDRAWSURFACE3 surface;
RECT srcrect, dstrect;
surface = overlay->hwdata->surface;
srcrect.top = src->y;
srcrect.bottom = srcrect.top + src->h;
srcrect.left = src->x;
srcrect.right = srcrect.left + src->w;
dstrect.top = SDL_bounds.top + dst->y;
dstrect.left = SDL_bounds.left + dst->x;
dstrect.bottom = dstrect.top + dst->h;
dstrect.right = dstrect.left + dst->w;
275
#ifdef USE_DIRECTX_OVERLAY
276
277
278
result = IDirectDrawSurface3_UpdateOverlay(surface, &srcrect,
SDL_primary, &dstrect,
DDOVER_SHOW, NULL);
279
if (result != DD_OK) {
280
SetDDerror("DirectDrawSurface3::UpdateOverlay", result);
281
282
return (-1);
}
283
#else
284
result =
285
286
IDirectDrawSurface3_Blt(SDL_primary, &dstrect, surface, &srcrect,
DDBLT_WAIT, NULL);
287
if (result != DD_OK) {
288
SetDDerror("DirectDrawSurface3::Blt", result);
289
290
return (-1);
}
291
#endif
292
return (0);
293
294
}
295
void
296
DX5_FreeYUVOverlay(_THIS, SDL_Overlay * overlay)
297
{
298
299
300
301
302
struct private_yuvhwdata *hwdata;
hwdata = overlay->hwdata;
if (hwdata) {
if (hwdata->surface) {
303
IDirectDrawSurface_Release(hwdata->surface);
304
}
305
SDL_free(hwdata);
306
}
307
308
}
309
/* vi: set ts=4 sw=4 expandtab: */