1 /* 2 SDL - Simple DirectMedia Layer 3 Copyright (C) 1997-2012 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 This library is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 Lesser General Public License for more details. 14 15 You should have received a copy of the GNU Lesser General Public 16 License along with this library; if not, write to the Free Software 17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 18 19 Sam Lantinga 20 slouken (at) libsdl.org 21 */ 22 #include "SDL_config.h" 23 24 /* This is the software implementation of the YUV video overlay support */ 25 26 /* This code was derived from code carrying the following copyright notices: 27 28 * Copyright (c) 1995 The Regents of the University of California. 29 * All rights reserved. 30 * 31 * Permission to use, copy, modify, and distribute this software and its 32 * documentation for any purpose, without fee, and without written agreement is 33 * hereby granted, provided that the above copyright notice and the following 34 * two paragraphs appear in all copies of this software. 35 * 36 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR 37 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT 38 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF 39 * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 40 * 41 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, 42 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 43 * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS 44 * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO 45 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. 46 47 * Copyright (c) 1995 Erik Corry 48 * All rights reserved. 49 * 50 * Permission to use, copy, modify, and distribute this software and its 51 * documentation for any purpose, without fee, and without written agreement is 52 * hereby granted, provided that the above copyright notice and the following 53 * two paragraphs appear in all copies of this software. 54 * 55 * IN NO EVENT SHALL ERIK CORRY BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, 56 * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF 57 * THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF ERIK CORRY HAS BEEN ADVISED 58 * OF THE POSSIBILITY OF SUCH DAMAGE. 59 * 60 * ERIK CORRY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT 61 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 62 * PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" 63 * BASIS, AND ERIK CORRY HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, 64 * UPDATES, ENHANCEMENTS, OR MODIFICATIONS. 65 66 * Portions of this software Copyright (c) 1995 Brown University. 67 * All rights reserved. 68 * 69 * Permission to use, copy, modify, and distribute this software and its 70 * documentation for any purpose, without fee, and without written agreement 71 * is hereby granted, provided that the above copyright notice and the 72 * following two paragraphs appear in all copies of this software. 73 * 74 * IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE TO ANY PARTY FOR 75 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT 76 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF BROWN 77 * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 78 * 79 * BROWN UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT 80 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 81 * PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" 82 * BASIS, AND BROWN UNIVERSITY HAS NO OBLIGATION TO PROVIDE MAINTENANCE, 83 * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. 84 */ 85 86 #include "SDL_video.h" 87 #include "SDL_cpuinfo.h" 88 #include "SDL_stretch_c.h" 89 #include "SDL_yuvfuncs.h" 90 #include "SDL_yuv_sw_c.h" 91 92 /* The functions used to manipulate software video overlays */ 93 static struct private_yuvhwfuncs sw_yuvfuncs = { 94 SDL_LockYUV_SW, 95 SDL_UnlockYUV_SW, 96 SDL_DisplayYUV_SW, 97 SDL_FreeYUV_SW 98 }; 99 100 /* RGB conversion lookup tables */ 101 struct private_yuvhwdata { 102 SDL_Surface *stretch; 103 SDL_Surface *display; 104 Uint8 *pixels; 105 int *colortab; 106 Uint32 *rgb_2_pix; 107 void (*Display1X)(int *colortab, Uint32 *rgb_2_pix, 108 unsigned char *lum, unsigned char *cr, 109 unsigned char *cb, unsigned char *out, 110 int rows, int cols, int mod ); 111 void (*Display2X)(int *colortab, Uint32 *rgb_2_pix, 112 unsigned char *lum, unsigned char *cr, 113 unsigned char *cb, unsigned char *out, 114 int rows, int cols, int mod ); 115 116 /* These are just so we don't have to allocate them separately */ 117 Uint16 pitches[3]; 118 Uint8 *planes[3]; 119 }; 120 121 122 /* The colorspace conversion functions */ 123 124 #if (__GNUC__ > 2) && defined(__i386__) && __OPTIMIZE__ && SDL_ASSEMBLY_ROUTINES 125 extern void Color565DitherYV12MMX1X( int *colortab, Uint32 *rgb_2_pix, 126 unsigned char *lum, unsigned char *cr, 127 unsigned char *cb, unsigned char *out, 128 int rows, int cols, int mod ); 129 extern void ColorRGBDitherYV12MMX1X( int *colortab, Uint32 *rgb_2_pix, 130 unsigned char *lum, unsigned char *cr, 131 unsigned char *cb, unsigned char *out, 132 int rows, int cols, int mod ); 133 #endif 134 135 static void Color16DitherYV12Mod1X( int *colortab, Uint32 *rgb_2_pix, 136 unsigned char *lum, unsigned char *cr, 137 unsigned char *cb, unsigned char *out, 138 int rows, int cols, int mod ) 139 { 140 unsigned short* row1; 141 unsigned short* row2; 142 unsigned char* lum2; 143 int x, y; 144 int cr_r; 145 int crb_g; 146 int cb_b; 147 int cols_2 = cols / 2; 148 149 row1 = (unsigned short*) out; 150 row2 = row1 + cols + mod; 151 lum2 = lum + cols; 152 153 mod += cols + mod; 154 155 y = rows / 2; 156 while( y-- ) 157 { 158 x = cols_2; 159 while( x-- ) 160 { 161 register int L; 162 163 cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; 164 crb_g = 1*768+256 + colortab[ *cr + 1*256 ] 165 + colortab[ *cb + 2*256 ]; 166 cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; 167 ++cr; ++cb; 168 169 L = *lum++; 170 *row1++ = (unsigned short)(rgb_2_pix[ L + cr_r ] | 171 rgb_2_pix[ L + crb_g ] | 172 rgb_2_pix[ L + cb_b ]); 173 174 L = *lum++; 175 *row1++ = (unsigned short)(rgb_2_pix[ L + cr_r ] | 176 rgb_2_pix[ L + crb_g ] | 177 rgb_2_pix[ L + cb_b ]); 178 179 180 /* Now, do second row. */ 181 182 L = *lum2++; 183 *row2++ = (unsigned short)(rgb_2_pix[ L + cr_r ] | 184 rgb_2_pix[ L + crb_g ] | 185 rgb_2_pix[ L + cb_b ]); 186 187 L = *lum2++; 188 *row2++ = (unsigned short)(rgb_2_pix[ L + cr_r ] | 189 rgb_2_pix[ L + crb_g ] | 190 rgb_2_pix[ L + cb_b ]); 191 } 192 193 /* 194 * These values are at the start of the next line, (due 195 * to the ++'s above),but they need to be at the start 196 * of the line after that. 197 */ 198 lum += cols; 199 lum2 += cols; 200 row1 += mod; 201 row2 += mod; 202 } 203 } 204 205 static void Color24DitherYV12Mod1X( int *colortab, Uint32 *rgb_2_pix, 206 unsigned char *lum, unsigned char *cr, 207 unsigned char *cb, unsigned char *out, 208 int rows, int cols, int mod ) 209 { 210 unsigned int value; 211 unsigned char* row1; 212 unsigned char* row2; 213 unsigned char* lum2; 214 int x, y; 215 int cr_r; 216 int crb_g; 217 int cb_b; 218 int cols_2 = cols / 2; 219 220 row1 = out; 221 row2 = row1 + cols*3 + mod*3; 222 lum2 = lum + cols; 223 224 mod += cols + mod; 225 mod *= 3; 226 227 y = rows / 2; 228 while( y-- ) 229 { 230 x = cols_2; 231 while( x-- ) 232 { 233 register int L; 234 235 cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; 236 crb_g = 1*768+256 + colortab[ *cr + 1*256 ] 237 + colortab[ *cb + 2*256 ]; 238 cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; 239 ++cr; ++cb; 240 241 L = *lum++; 242 value = (rgb_2_pix[ L + cr_r ] | 243 rgb_2_pix[ L + crb_g ] | 244 rgb_2_pix[ L + cb_b ]); 245 *row1++ = (value ) & 0xFF; 246 *row1++ = (value >> 8) & 0xFF; 247 *row1++ = (value >> 16) & 0xFF; 248 249 L = *lum++; 250 value = (rgb_2_pix[ L + cr_r ] | 251 rgb_2_pix[ L + crb_g ] | 252 rgb_2_pix[ L + cb_b ]); 253 *row1++ = (value ) & 0xFF; 254 *row1++ = (value >> 8) & 0xFF; 255 *row1++ = (value >> 16) & 0xFF; 256 257 258 /* Now, do second row. */ 259 260 L = *lum2++; 261 value = (rgb_2_pix[ L + cr_r ] | 262 rgb_2_pix[ L + crb_g ] | 263 rgb_2_pix[ L + cb_b ]); 264 *row2++ = (value ) & 0xFF; 265 *row2++ = (value >> 8) & 0xFF; 266 *row2++ = (value >> 16) & 0xFF; 267 268 L = *lum2++; 269 value = (rgb_2_pix[ L + cr_r ] | 270 rgb_2_pix[ L + crb_g ] | 271 rgb_2_pix[ L + cb_b ]); 272 *row2++ = (value ) & 0xFF; 273 *row2++ = (value >> 8) & 0xFF; 274 *row2++ = (value >> 16) & 0xFF; 275 } 276 277 /* 278 * These values are at the start of the next line, (due 279 * to the ++'s above),but they need to be at the start 280 * of the line after that. 281 */ 282 lum += cols; 283 lum2 += cols; 284 row1 += mod; 285 row2 += mod; 286 } 287 } 288 289 static void Color32DitherYV12Mod1X( int *colortab, Uint32 *rgb_2_pix, 290 unsigned char *lum, unsigned char *cr, 291 unsigned char *cb, unsigned char *out, 292 int rows, int cols, int mod ) 293 { 294 unsigned int* row1; 295 unsigned int* row2; 296 unsigned char* lum2; 297 int x, y; 298 int cr_r; 299 int crb_g; 300 int cb_b; 301 int cols_2 = cols / 2; 302 303 row1 = (unsigned int*) out; 304 row2 = row1 + cols + mod; 305 lum2 = lum + cols; 306 307 mod += cols + mod; 308 309 y = rows / 2; 310 while( y-- ) 311 { 312 x = cols_2; 313 while( x-- ) 314 { 315 register int L; 316 317 cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; 318 crb_g = 1*768+256 + colortab[ *cr + 1*256 ] 319 + colortab[ *cb + 2*256 ]; 320 cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; 321 ++cr; ++cb; 322 323 L = *lum++; 324 *row1++ = (rgb_2_pix[ L + cr_r ] | 325 rgb_2_pix[ L + crb_g ] | 326 rgb_2_pix[ L + cb_b ]); 327 328 L = *lum++; 329 *row1++ = (rgb_2_pix[ L + cr_r ] | 330 rgb_2_pix[ L + crb_g ] | 331 rgb_2_pix[ L + cb_b ]); 332 333 334 /* Now, do second row. */ 335 336 L = *lum2++; 337 *row2++ = (rgb_2_pix[ L + cr_r ] | 338 rgb_2_pix[ L + crb_g ] | 339 rgb_2_pix[ L + cb_b ]); 340 341 L = *lum2++; 342 *row2++ = (rgb_2_pix[ L + cr_r ] | 343 rgb_2_pix[ L + crb_g ] | 344 rgb_2_pix[ L + cb_b ]); 345 } 346 347 /* 348 * These values are at the start of the next line, (due 349 * to the ++'s above),but they need to be at the start 350 * of the line after that. 351 */ 352 lum += cols; 353 lum2 += cols; 354 row1 += mod; 355 row2 += mod; 356 } 357 } 358 359 /* 360 * In this function I make use of a nasty trick. The tables have the lower 361 * 16 bits replicated in the upper 16. This means I can write ints and get 362 * the horisontal doubling for free (almost). 363 */ 364 static void Color16DitherYV12Mod2X( int *colortab, Uint32 *rgb_2_pix, 365 unsigned char *lum, unsigned char *cr, 366 unsigned char *cb, unsigned char *out, 367 int rows, int cols, int mod ) 368 { 369 unsigned int* row1 = (unsigned int*) out; 370 const int next_row = cols+(mod/2); 371 unsigned int* row2 = row1 + 2*next_row; 372 unsigned char* lum2; 373 int x, y; 374 int cr_r; 375 int crb_g; 376 int cb_b; 377 int cols_2 = cols / 2; 378 379 lum2 = lum + cols; 380 381 mod = (next_row * 3) + (mod/2); 382 383 y = rows / 2; 384 while( y-- ) 385 { 386 x = cols_2; 387 while( x-- ) 388 { 389 register int L; 390 391 cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; 392 crb_g = 1*768+256 + colortab[ *cr + 1*256 ] 393 + colortab[ *cb + 2*256 ]; 394 cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; 395 ++cr; ++cb; 396 397 L = *lum++; 398 row1[0] = row1[next_row] = (rgb_2_pix[ L + cr_r ] | 399 rgb_2_pix[ L + crb_g ] | 400 rgb_2_pix[ L + cb_b ]); 401 row1++; 402 403 L = *lum++; 404 row1[0] = row1[next_row] = (rgb_2_pix[ L + cr_r ] | 405 rgb_2_pix[ L + crb_g ] | 406 rgb_2_pix[ L + cb_b ]); 407 row1++; 408 409 410 /* Now, do second row. */ 411 412 L = *lum2++; 413 row2[0] = row2[next_row] = (rgb_2_pix[ L + cr_r ] | 414 rgb_2_pix[ L + crb_g ] | 415 rgb_2_pix[ L + cb_b ]); 416 row2++; 417 418 L = *lum2++; 419 row2[0] = row2[next_row] = (rgb_2_pix[ L + cr_r ] | 420 rgb_2_pix[ L + crb_g ] | 421 rgb_2_pix[ L + cb_b ]); 422 row2++; 423 } 424 425 /* 426 * These values are at the start of the next line, (due 427 * to the ++'s above),but they need to be at the start 428 * of the line after that. 429 */ 430 lum += cols; 431 lum2 += cols; 432 row1 += mod; 433 row2 += mod; 434 } 435 } 436 437 static void Color24DitherYV12Mod2X( int *colortab, Uint32 *rgb_2_pix, 438 unsigned char *lum, unsigned char *cr, 439 unsigned char *cb, unsigned char *out, 440 int rows, int cols, int mod ) 441 { 442 unsigned int value; 443 unsigned char* row1 = out; 444 const int next_row = (cols*2 + mod) * 3; 445 unsigned char* row2 = row1 + 2*next_row; 446 unsigned char* lum2; 447 int x, y; 448 int cr_r; 449 int crb_g; 450 int cb_b; 451 int cols_2 = cols / 2; 452 453 lum2 = lum + cols; 454 455 mod = next_row*3 + mod*3; 456 457 y = rows / 2; 458 while( y-- ) 459 { 460 x = cols_2; 461 while( x-- ) 462 { 463 register int L; 464 465 cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; 466 crb_g = 1*768+256 + colortab[ *cr + 1*256 ] 467 + colortab[ *cb + 2*256 ]; 468 cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; 469 ++cr; ++cb; 470 471 L = *lum++; 472 value = (rgb_2_pix[ L + cr_r ] | 473 rgb_2_pix[ L + crb_g ] | 474 rgb_2_pix[ L + cb_b ]); 475 row1[0+0] = row1[3+0] = row1[next_row+0] = row1[next_row+3+0] = 476 (value ) & 0xFF; 477 row1[0+1] = row1[3+1] = row1[next_row+1] = row1[next_row+3+1] = 478 (value >> 8) & 0xFF; 479 row1[0+2] = row1[3+2] = row1[next_row+2] = row1[next_row+3+2] = 480 (value >> 16) & 0xFF; 481 row1 += 2*3; 482 483 L = *lum++; 484 value = (rgb_2_pix[ L + cr_r ] | 485 rgb_2_pix[ L + crb_g ] | 486 rgb_2_pix[ L + cb_b ]); 487 row1[0+0] = row1[3+0] = row1[next_row+0] = row1[next_row+3+0] = 488 (value ) & 0xFF; 489 row1[0+1] = row1[3+1] = row1[next_row+1] = row1[next_row+3+1] = 490 (value >> 8) & 0xFF; 491 row1[0+2] = row1[3+2] = row1[next_row+2] = row1[next_row+3+2] = 492 (value >> 16) & 0xFF; 493 row1 += 2*3; 494 495 496 /* Now, do second row. */ 497 498 L = *lum2++; 499 value = (rgb_2_pix[ L + cr_r ] | 500 rgb_2_pix[ L + crb_g ] | 501 rgb_2_pix[ L + cb_b ]); 502 row2[0+0] = row2[3+0] = row2[next_row+0] = row2[next_row+3+0] = 503 (value ) & 0xFF; 504 row2[0+1] = row2[3+1] = row2[next_row+1] = row2[next_row+3+1] = 505 (value >> 8) & 0xFF; 506 row2[0+2] = row2[3+2] = row2[next_row+2] = row2[next_row+3+2] = 507 (value >> 16) & 0xFF; 508 row2 += 2*3; 509 510 L = *lum2++; 511 value = (rgb_2_pix[ L + cr_r ] | 512 rgb_2_pix[ L + crb_g ] | 513 rgb_2_pix[ L + cb_b ]); 514 row2[0+0] = row2[3+0] = row2[next_row+0] = row2[next_row+3+0] = 515 (value ) & 0xFF; 516 row2[0+1] = row2[3+1] = row2[next_row+1] = row2[next_row+3+1] = 517 (value >> 8) & 0xFF; 518 row2[0+2] = row2[3+2] = row2[next_row+2] = row2[next_row+3+2] = 519 (value >> 16) & 0xFF; 520 row2 += 2*3; 521 } 522 523 /* 524 * These values are at the start of the next line, (due 525 * to the ++'s above),but they need to be at the start 526 * of the line after that. 527 */ 528 lum += cols; 529 lum2 += cols; 530 row1 += mod; 531 row2 += mod; 532 } 533 } 534 535 static void Color32DitherYV12Mod2X( int *colortab, Uint32 *rgb_2_pix, 536 unsigned char *lum, unsigned char *cr, 537 unsigned char *cb, unsigned char *out, 538 int rows, int cols, int mod ) 539 { 540 unsigned int* row1 = (unsigned int*) out; 541 const int next_row = cols*2+mod; 542 unsigned int* row2 = row1 + 2*next_row; 543 unsigned char* lum2; 544 int x, y; 545 int cr_r; 546 int crb_g; 547 int cb_b; 548 int cols_2 = cols / 2; 549 550 lum2 = lum + cols; 551 552 mod = (next_row * 3) + mod; 553 554 y = rows / 2; 555 while( y-- ) 556 { 557 x = cols_2; 558 while( x-- ) 559 { 560 register int L; 561 562 cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; 563 crb_g = 1*768+256 + colortab[ *cr + 1*256 ] 564 + colortab[ *cb + 2*256 ]; 565 cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; 566 ++cr; ++cb; 567 568 L = *lum++; 569 row1[0] = row1[1] = row1[next_row] = row1[next_row+1] = 570 (rgb_2_pix[ L + cr_r ] | 571 rgb_2_pix[ L + crb_g ] | 572 rgb_2_pix[ L + cb_b ]); 573 row1 += 2; 574 575 L = *lum++; 576 row1[0] = row1[1] = row1[next_row] = row1[next_row+1] = 577 (rgb_2_pix[ L + cr_r ] | 578 rgb_2_pix[ L + crb_g ] | 579 rgb_2_pix[ L + cb_b ]); 580 row1 += 2; 581 582 583 /* Now, do second row. */ 584 585 L = *lum2++; 586 row2[0] = row2[1] = row2[next_row] = row2[next_row+1] = 587 (rgb_2_pix[ L + cr_r ] | 588 rgb_2_pix[ L + crb_g ] | 589 rgb_2_pix[ L + cb_b ]); 590 row2 += 2; 591 592 L = *lum2++; 593 row2[0] = row2[1] = row2[next_row] = row2[next_row+1] = 594 (rgb_2_pix[ L + cr_r ] | 595 rgb_2_pix[ L + crb_g ] | 596 rgb_2_pix[ L + cb_b ]); 597 row2 += 2; 598 } 599 600 /* 601 * These values are at the start of the next line, (due 602 * to the ++'s above),but they need to be at the start 603 * of the line after that. 604 */ 605 lum += cols; 606 lum2 += cols; 607 row1 += mod; 608 row2 += mod; 609 } 610 } 611 612 static void Color16DitherYUY2Mod1X( int *colortab, Uint32 *rgb_2_pix, 613 unsigned char *lum, unsigned char *cr, 614 unsigned char *cb, unsigned char *out, 615 int rows, int cols, int mod ) 616 { 617 unsigned short* row; 618 int x, y; 619 int cr_r; 620 int crb_g; 621 int cb_b; 622 int cols_2 = cols / 2; 623 624 row = (unsigned short*) out; 625 626 y = rows; 627 while( y-- ) 628 { 629 x = cols_2; 630 while( x-- ) 631 { 632 register int L; 633 634 cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; 635 crb_g = 1*768+256 + colortab[ *cr + 1*256 ] 636 + colortab[ *cb + 2*256 ]; 637 cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; 638 cr += 4; cb += 4; 639 640 L = *lum; lum += 2; 641 *row++ = (unsigned short)(rgb_2_pix[ L + cr_r ] | 642 rgb_2_pix[ L + crb_g ] | 643 rgb_2_pix[ L + cb_b ]); 644 645 L = *lum; lum += 2; 646 *row++ = (unsigned short)(rgb_2_pix[ L + cr_r ] | 647 rgb_2_pix[ L + crb_g ] | 648 rgb_2_pix[ L + cb_b ]); 649 650 } 651 652 row += mod; 653 } 654 } 655 656 static void Color24DitherYUY2Mod1X( int *colortab, Uint32 *rgb_2_pix, 657 unsigned char *lum, unsigned char *cr, 658 unsigned char *cb, unsigned char *out, 659 int rows, int cols, int mod ) 660 { 661 unsigned int value; 662 unsigned char* row; 663 int x, y; 664 int cr_r; 665 int crb_g; 666 int cb_b; 667 int cols_2 = cols / 2; 668 669 row = (unsigned char*) out; 670 mod *= 3; 671 y = rows; 672 while( y-- ) 673 { 674 x = cols_2; 675 while( x-- ) 676 { 677 register int L; 678 679 cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; 680 crb_g = 1*768+256 + colortab[ *cr + 1*256 ] 681 + colortab[ *cb + 2*256 ]; 682 cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; 683 cr += 4; cb += 4; 684 685 L = *lum; lum += 2; 686 value = (rgb_2_pix[ L + cr_r ] | 687 rgb_2_pix[ L + crb_g ] | 688 rgb_2_pix[ L + cb_b ]); 689 *row++ = (value ) & 0xFF; 690 *row++ = (value >> 8) & 0xFF; 691 *row++ = (value >> 16) & 0xFF; 692 693 L = *lum; lum += 2; 694 value = (rgb_2_pix[ L + cr_r ] | 695 rgb_2_pix[ L + crb_g ] | 696 rgb_2_pix[ L + cb_b ]); 697 *row++ = (value ) & 0xFF; 698 *row++ = (value >> 8) & 0xFF; 699 *row++ = (value >> 16) & 0xFF; 700 701 } 702 row += mod; 703 } 704 } 705 706 static void Color32DitherYUY2Mod1X( int *colortab, Uint32 *rgb_2_pix, 707 unsigned char *lum, unsigned char *cr, 708 unsigned char *cb, unsigned char *out, 709 int rows, int cols, int mod ) 710 { 711 unsigned int* row; 712 int x, y; 713 int cr_r; 714 int crb_g; 715 int cb_b; 716 int cols_2 = cols / 2; 717 718 row = (unsigned int*) out; 719 y = rows; 720 while( y-- ) 721 { 722 x = cols_2; 723 while( x-- ) 724 { 725 register int L; 726 727 cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; 728 crb_g = 1*768+256 + colortab[ *cr + 1*256 ] 729 + colortab[ *cb + 2*256 ]; 730 cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; 731 cr += 4; cb += 4; 732 733 L = *lum; lum += 2; 734 *row++ = (rgb_2_pix[ L + cr_r ] | 735 rgb_2_pix[ L + crb_g ] | 736 rgb_2_pix[ L + cb_b ]); 737 738 L = *lum; lum += 2; 739 *row++ = (rgb_2_pix[ L + cr_r ] | 740 rgb_2_pix[ L + crb_g ] | 741 rgb_2_pix[ L + cb_b ]); 742 743 744 } 745 row += mod; 746 } 747 } 748 749 /* 750 * In this function I make use of a nasty trick. The tables have the lower 751 * 16 bits replicated in the upper 16. This means I can write ints and get 752 * the horisontal doubling for free (almost). 753 */ 754 static void Color16DitherYUY2Mod2X( int *colortab, Uint32 *rgb_2_pix, 755 unsigned char *lum, unsigned char *cr, 756 unsigned char *cb, unsigned char *out, 757 int rows, int cols, int mod ) 758 { 759 unsigned int* row = (unsigned int*) out; 760 const int next_row = cols+(mod/2); 761 int x, y; 762 int cr_r; 763 int crb_g; 764 int cb_b; 765 int cols_2 = cols / 2; 766 767 y = rows; 768 while( y-- ) 769 { 770 x = cols_2; 771 while( x-- ) 772 { 773 register int L; 774 775 cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; 776 crb_g = 1*768+256 + colortab[ *cr + 1*256 ] 777 + colortab[ *cb + 2*256 ]; 778 cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; 779 cr += 4; cb += 4; 780 781 L = *lum; lum += 2; 782 row[0] = row[next_row] = (rgb_2_pix[ L + cr_r ] | 783 rgb_2_pix[ L + crb_g ] | 784 rgb_2_pix[ L + cb_b ]); 785 row++; 786 787 L = *lum; lum += 2; 788 row[0] = row[next_row] = (rgb_2_pix[ L + cr_r ] | 789 rgb_2_pix[ L + crb_g ] | 790 rgb_2_pix[ L + cb_b ]); 791 row++; 792 793 } 794 row += next_row; 795 } 796 } 797 798 static void Color24DitherYUY2Mod2X( int *colortab, Uint32 *rgb_2_pix, 799 unsigned char *lum, unsigned char *cr, 800 unsigned char *cb, unsigned char *out, 801 int rows, int cols, int mod ) 802 { 803 unsigned int value; 804 unsigned char* row = out; 805 const int next_row = (cols*2 + mod) * 3; 806 int x, y; 807 int cr_r; 808 int crb_g; 809 int cb_b; 810 int cols_2 = cols / 2; 811 y = rows; 812 while( y-- ) 813 { 814 x = cols_2; 815 while( x-- ) 816 { 817 register int L; 818 819 cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; 820 crb_g = 1*768+256 + colortab[ *cr + 1*256 ] 821 + colortab[ *cb + 2*256 ]; 822 cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; 823 cr += 4; cb += 4; 824 825 L = *lum; lum += 2; 826 value = (rgb_2_pix[ L + cr_r ] | 827 rgb_2_pix[ L + crb_g ] | 828 rgb_2_pix[ L + cb_b ]); 829 row[0+0] = row[3+0] = row[next_row+0] = row[next_row+3+0] = 830 (value ) & 0xFF; 831 row[0+1] = row[3+1] = row[next_row+1] = row[next_row+3+1] = 832 (value >> 8) & 0xFF; 833 row[0+2] = row[3+2] = row[next_row+2] = row[next_row+3+2] = 834 (value >> 16) & 0xFF; 835 row += 2*3; 836 837 L = *lum; lum += 2; 838 value = (rgb_2_pix[ L + cr_r ] | 839 rgb_2_pix[ L + crb_g ] | 840 rgb_2_pix[ L + cb_b ]); 841 row[0+0] = row[3+0] = row[next_row+0] = row[next_row+3+0] = 842 (value ) & 0xFF; 843 row[0+1] = row[3+1] = row[next_row+1] = row[next_row+3+1] = 844 (value >> 8) & 0xFF; 845 row[0+2] = row[3+2] = row[next_row+2] = row[next_row+3+2] = 846 (value >> 16) & 0xFF; 847 row += 2*3; 848 849 } 850 row += next_row; 851 } 852 } 853 854 static void Color32DitherYUY2Mod2X( int *colortab, Uint32 *rgb_2_pix, 855 unsigned char *lum, unsigned char *cr, 856 unsigned char *cb, unsigned char *out, 857 int rows, int cols, int mod ) 858 { 859 unsigned int* row = (unsigned int*) out; 860 const int next_row = cols*2+mod; 861 int x, y; 862 int cr_r; 863 int crb_g; 864 int cb_b; 865 int cols_2 = cols / 2; 866 mod+=mod; 867 y = rows; 868 while( y-- ) 869 { 870 x = cols_2; 871 while( x-- ) 872 { 873 register int L; 874 875 cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; 876 crb_g = 1*768+256 + colortab[ *cr + 1*256 ] 877 + colortab[ *cb + 2*256 ]; 878 cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; 879 cr += 4; cb += 4; 880 881 L = *lum; lum += 2; 882 row[0] = row[1] = row[next_row] = row[next_row+1] = 883 (rgb_2_pix[ L + cr_r ] | 884 rgb_2_pix[ L + crb_g ] | 885 rgb_2_pix[ L + cb_b ]); 886 row += 2; 887 888 L = *lum; lum += 2; 889 row[0] = row[1] = row[next_row] = row[next_row+1] = 890 (rgb_2_pix[ L + cr_r ] | 891 rgb_2_pix[ L + crb_g ] | 892 rgb_2_pix[ L + cb_b ]); 893 row += 2; 894 895 896 } 897 898 row += next_row; 899 } 900 } 901 902 /* 903 * How many 1 bits are there in the Uint32. 904 * Low performance, do not call often. 905 */ 906 static int number_of_bits_set( Uint32 a ) 907 { 908 if(!a) return 0; 909 if(a & 1) return 1 + number_of_bits_set(a >> 1); 910 return(number_of_bits_set(a >> 1)); 911 } 912 913 /* 914 * How many 0 bits are there at least significant end of Uint32. 915 * Low performance, do not call often. 916 */ 917 static int free_bits_at_bottom( Uint32 a ) 918 { 919 /* assume char is 8 bits */ 920 if(!a) return sizeof(Uint32) * 8; 921 if(((Sint32)a) & 1l) return 0; 922 return 1 + free_bits_at_bottom ( a >> 1); 923 } 924 925 926 SDL_Overlay *SDL_CreateYUV_SW(_THIS, int width, int height, Uint32 format, SDL_Surface *display) 927 { 928 SDL_Overlay *overlay; 929 struct private_yuvhwdata *swdata; 930 int *Cr_r_tab; 931 int *Cr_g_tab; 932 int *Cb_g_tab; 933 int *Cb_b_tab; 934 Uint32 *r_2_pix_alloc; 935 Uint32 *g_2_pix_alloc; 936 Uint32 *b_2_pix_alloc; 937 int i; 938 int CR, CB; 939 Uint32 Rmask, Gmask, Bmask; 940 941 /* Only RGB packed pixel conversion supported */ 942 if ( (display->format->BytesPerPixel != 2) && 943 (display->format->BytesPerPixel != 3) && 944 (display->format->BytesPerPixel != 4) ) { 945 SDL_SetError("Can't use YUV data on non 16/24/32 bit surfaces"); 946 return(NULL); 947 } 948 949 /* Verify that we support the format */ 950 switch (format) { 951 case SDL_YV12_OVERLAY: 952 case SDL_IYUV_OVERLAY: 953 case SDL_YUY2_OVERLAY: 954 case SDL_UYVY_OVERLAY: 955 case SDL_YVYU_OVERLAY: 956 break; 957 default: 958 SDL_SetError("Unsupported YUV format"); 959 return(NULL); 960 } 961 962 /* Create the overlay structure */ 963 overlay = (SDL_Overlay *)SDL_malloc(sizeof *overlay); 964 if ( overlay == NULL ) { 965 SDL_OutOfMemory(); 966 return(NULL); 967 } 968 SDL_memset(overlay, 0, (sizeof *overlay)); 969 970 /* Fill in the basic members */ 971 overlay->format = format; 972 overlay->w = width; 973 overlay->h = height; 974 975 /* Set up the YUV surface function structure */ 976 overlay->hwfuncs = &sw_yuvfuncs; 977 978 /* Create the pixel data and lookup tables */ 979 swdata = (struct private_yuvhwdata *)SDL_malloc(sizeof *swdata); 980 overlay->hwdata = swdata; 981 if ( swdata == NULL ) { 982 SDL_OutOfMemory(); 983 SDL_FreeYUVOverlay(overlay); 984 return(NULL); 985 } 986 swdata->stretch = NULL; 987 swdata->display = display; 988 swdata->pixels = (Uint8 *) SDL_malloc(width*height*2); 989 swdata->colortab = (int *)SDL_malloc(4*256*sizeof(int)); 990 Cr_r_tab = &swdata->colortab[0*256]; 991 Cr_g_tab = &swdata->colortab[1*256]; 992 Cb_g_tab = &swdata->colortab[2*256]; 993 Cb_b_tab = &swdata->colortab[3*256]; 994 swdata->rgb_2_pix = (Uint32 *)SDL_malloc(3*768*sizeof(Uint32)); 995 r_2_pix_alloc = &swdata->rgb_2_pix[0*768]; 996 g_2_pix_alloc = &swdata->rgb_2_pix[1*768]; 997 b_2_pix_alloc = &swdata->rgb_2_pix[2*768]; 998 if ( ! swdata->pixels || ! swdata->colortab || ! swdata->rgb_2_pix ) { 999 SDL_OutOfMemory(); 1000 SDL_FreeYUVOverlay(overlay); 1001 return(NULL); 1002 } 1003 1004 /* Generate the tables for the display surface */ 1005 for (i=0; i<256; i++) { 1006 /* Gamma correction (luminescence table) and chroma correction 1007 would be done here. See the Berkeley mpeg_play sources. 1008 */ 1009 CB = CR = (i-128); 1010 Cr_r_tab[i] = (int) ( (0.419/0.299) * CR); 1011 Cr_g_tab[i] = (int) (-(0.299/0.419) * CR); 1012 Cb_g_tab[i] = (int) (-(0.114/0.331) * CB); 1013 Cb_b_tab[i] = (int) ( (0.587/0.331) * CB); 1014 } 1015 1016 /* 1017 * Set up entries 0-255 in rgb-to-pixel value tables. 1018 */ 1019 Rmask = display->format->Rmask; 1020 Gmask = display->format->Gmask; 1021 Bmask = display->format->Bmask; 1022 for ( i=0; i<256; ++i ) { 1023 r_2_pix_alloc[i+256] = i >> (8 - number_of_bits_set(Rmask)); 1024 r_2_pix_alloc[i+256] <<= free_bits_at_bottom(Rmask); 1025 g_2_pix_alloc[i+256] = i >> (8 - number_of_bits_set(Gmask)); 1026 g_2_pix_alloc[i+256] <<= free_bits_at_bottom(Gmask); 1027 b_2_pix_alloc[i+256] = i >> (8 - number_of_bits_set(Bmask)); 1028 b_2_pix_alloc[i+256] <<= free_bits_at_bottom(Bmask); 1029 } 1030 1031 /* 1032 * If we have 16-bit output depth, then we double the value 1033 * in the top word. This means that we can write out both 1034 * pixels in the pixel doubling mode with one op. It is 1035 * harmless in the normal case as storing a 32-bit value 1036 * through a short pointer will lose the top bits anyway. 1037 */ 1038 if( display->format->BytesPerPixel == 2 ) { 1039 for ( i=0; i<256; ++i ) { 1040 r_2_pix_alloc[i+256] |= (r_2_pix_alloc[i+256]) << 16; 1041 g_2_pix_alloc[i+256] |= (g_2_pix_alloc[i+256]) << 16; 1042 b_2_pix_alloc[i+256] |= (b_2_pix_alloc[i+256]) << 16; 1043 } 1044 } 1045 1046 /* 1047 * Spread out the values we have to the rest of the array so that 1048 * we do not need to check for overflow. 1049 */ 1050 for ( i=0; i<256; ++i ) { 1051 r_2_pix_alloc[i] = r_2_pix_alloc[256]; 1052 r_2_pix_alloc[i+512] = r_2_pix_alloc[511]; 1053 g_2_pix_alloc[i] = g_2_pix_alloc[256]; 1054 g_2_pix_alloc[i+512] = g_2_pix_alloc[511]; 1055 b_2_pix_alloc[i] = b_2_pix_alloc[256]; 1056 b_2_pix_alloc[i+512] = b_2_pix_alloc[511]; 1057 } 1058 1059 /* You have chosen wisely... */ 1060 switch (format) { 1061 case SDL_YV12_OVERLAY: 1062 case SDL_IYUV_OVERLAY: 1063 if ( display->format->BytesPerPixel == 2 ) { 1064 #if (__GNUC__ > 2) && defined(__i386__) && __OPTIMIZE__ && SDL_ASSEMBLY_ROUTINES 1065 /* inline assembly functions */ 1066 if ( SDL_HasMMX() && (Rmask == 0xF800) && 1067 (Gmask == 0x07E0) && 1068 (Bmask == 0x001F) && 1069 (width & 15) == 0) { 1070 /*printf("Using MMX 16-bit 565 dither\n");*/ 1071 swdata->Display1X = Color565DitherYV12MMX1X; 1072 } else { 1073 /*printf("Using C 16-bit dither\n");*/ 1074 swdata->Display1X = Color16DitherYV12Mod1X; 1075 } 1076 #else 1077 swdata->Display1X = Color16DitherYV12Mod1X; 1078 #endif 1079 swdata->Display2X = Color16DitherYV12Mod2X; 1080 } 1081 if ( display->format->BytesPerPixel == 3 ) { 1082 swdata->Display1X = Color24DitherYV12Mod1X; 1083 swdata->Display2X = Color24DitherYV12Mod2X; 1084 } 1085 if ( display->format->BytesPerPixel == 4 ) { 1086 #if (__GNUC__ > 2) && defined(__i386__) && __OPTIMIZE__ && SDL_ASSEMBLY_ROUTINES 1087 /* inline assembly functions */ 1088 if ( SDL_HasMMX() && (Rmask == 0x00FF0000) && 1089 (Gmask == 0x0000FF00) && 1090 (Bmask == 0x000000FF) && 1091 (width & 15) == 0) { 1092 /*printf("Using MMX 32-bit dither\n");*/ 1093 swdata->Display1X = ColorRGBDitherYV12MMX1X; 1094 } else { 1095 /*printf("Using C 32-bit dither\n");*/ 1096 swdata->Display1X = Color32DitherYV12Mod1X; 1097 } 1098 #else 1099 swdata->Display1X = Color32DitherYV12Mod1X; 1100 #endif 1101 swdata->Display2X = Color32DitherYV12Mod2X; 1102 } 1103 break; 1104 case SDL_YUY2_OVERLAY: 1105 case SDL_UYVY_OVERLAY: 1106 case SDL_YVYU_OVERLAY: 1107 if ( display->format->BytesPerPixel == 2 ) { 1108 swdata->Display1X = Color16DitherYUY2Mod1X; 1109 swdata->Display2X = Color16DitherYUY2Mod2X; 1110 } 1111 if ( display->format->BytesPerPixel == 3 ) { 1112 swdata->Display1X = Color24DitherYUY2Mod1X; 1113 swdata->Display2X = Color24DitherYUY2Mod2X; 1114 } 1115 if ( display->format->BytesPerPixel == 4 ) { 1116 swdata->Display1X = Color32DitherYUY2Mod1X; 1117 swdata->Display2X = Color32DitherYUY2Mod2X; 1118 } 1119 break; 1120 default: 1121 /* We should never get here (caught above) */ 1122 break; 1123 } 1124 1125 /* Find the pitch and offset values for the overlay */ 1126 overlay->pitches = swdata->pitches; 1127 overlay->pixels = swdata->planes; 1128 switch (format) { 1129 case SDL_YV12_OVERLAY: 1130 case SDL_IYUV_OVERLAY: 1131 overlay->pitches[0] = overlay->w; 1132 overlay->pitches[1] = overlay->pitches[0] / 2; 1133 overlay->pitches[2] = overlay->pitches[0] / 2; 1134 overlay->pixels[0] = swdata->pixels; 1135 overlay->pixels[1] = overlay->pixels[0] + 1136 overlay->pitches[0] * overlay->h; 1137 overlay->pixels[2] = overlay->pixels[1] + 1138 overlay->pitches[1] * overlay->h / 2; 1139 overlay->planes = 3; 1140 break; 1141 case SDL_YUY2_OVERLAY: 1142 case SDL_UYVY_OVERLAY: 1143 case SDL_YVYU_OVERLAY: 1144 overlay->pitches[0] = overlay->w*2; 1145 overlay->pixels[0] = swdata->pixels; 1146 overlay->planes = 1; 1147 break; 1148 default: 1149 /* We should never get here (caught above) */ 1150 break; 1151 } 1152 1153 /* We're all done.. */ 1154 return(overlay); 1155 } 1156 1157 int SDL_LockYUV_SW(_THIS, SDL_Overlay *overlay) 1158 { 1159 return(0); 1160 } 1161 1162 void SDL_UnlockYUV_SW(_THIS, SDL_Overlay *overlay) 1163 { 1164 return; 1165 } 1166 1167 int SDL_DisplayYUV_SW(_THIS, SDL_Overlay *overlay, SDL_Rect *src, SDL_Rect *dst) 1168 { 1169 struct private_yuvhwdata *swdata; 1170 int stretch; 1171 int scale_2x; 1172 SDL_Surface *display; 1173 Uint8 *lum, *Cr, *Cb; 1174 Uint8 *dstp; 1175 int mod; 1176 1177 swdata = overlay->hwdata; 1178 stretch = 0; 1179 scale_2x = 0; 1180 if ( src->x || src->y || src->w < overlay->w || src->h < overlay->h ) { 1181 /* The source rectangle has been clipped. 1182 Using a scratch surface is easier than adding clipped 1183 source support to all the blitters, plus that would 1184 slow them down in the general unclipped case. 1185 */ 1186 stretch = 1; 1187 } else if ( (src->w != dst->w) || (src->h != dst->h) ) { 1188 if ( (dst->w == 2*src->w) && 1189 (dst->h == 2*src->h) ) { 1190 scale_2x = 1; 1191 } else { 1192 stretch = 1; 1193 } 1194 } 1195 if ( stretch ) { 1196 if ( ! swdata->stretch ) { 1197 display = swdata->display; 1198 swdata->stretch = SDL_CreateRGBSurface( 1199 SDL_SWSURFACE, 1200 overlay->w, overlay->h, 1201 display->format->BitsPerPixel, 1202 display->format->Rmask, 1203 display->format->Gmask, 1204 display->format->Bmask, 0); 1205 if ( ! swdata->stretch ) { 1206 return(-1); 1207 } 1208 } 1209 display = swdata->stretch; 1210 } else { 1211 display = swdata->display; 1212 } 1213 switch (overlay->format) { 1214 case SDL_YV12_OVERLAY: 1215 lum = overlay->pixels[0]; 1216 Cr = overlay->pixels[1]; 1217 Cb = overlay->pixels[2]; 1218 break; 1219 case SDL_IYUV_OVERLAY: 1220 lum = overlay->pixels[0]; 1221 Cr = overlay->pixels[2]; 1222 Cb = overlay->pixels[1]; 1223 break; 1224 case SDL_YUY2_OVERLAY: 1225 lum = overlay->pixels[0]; 1226 Cr = lum + 3; 1227 Cb = lum + 1; 1228 break; 1229 case SDL_UYVY_OVERLAY: 1230 lum = overlay->pixels[0]+1; 1231 Cr = lum + 1; 1232 Cb = lum - 1; 1233 break; 1234 case SDL_YVYU_OVERLAY: 1235 lum = overlay->pixels[0]; 1236 Cr = lum + 1; 1237 Cb = lum + 3; 1238 break; 1239 default: 1240 SDL_SetError("Unsupported YUV format in blit"); 1241 return(-1); 1242 } 1243 if ( SDL_MUSTLOCK(display) ) { 1244 if ( SDL_LockSurface(display) < 0 ) { 1245 return(-1); 1246 } 1247 } 1248 if ( stretch ) { 1249 dstp = (Uint8 *)swdata->stretch->pixels; 1250 } else { 1251 dstp = (Uint8 *)display->pixels 1252 + dst->x * display->format->BytesPerPixel 1253 + dst->y * display->pitch; 1254 } 1255 mod = (display->pitch / display->format->BytesPerPixel); 1256 1257 if ( scale_2x ) { 1258 mod -= (overlay->w * 2); 1259 swdata->Display2X(swdata->colortab, swdata->rgb_2_pix, 1260 lum, Cr, Cb, dstp, overlay->h, overlay->w, mod); 1261 } else { 1262 mod -= overlay->w; 1263 swdata->Display1X(swdata->colortab, swdata->rgb_2_pix, 1264 lum, Cr, Cb, dstp, overlay->h, overlay->w, mod); 1265 } 1266 if ( SDL_MUSTLOCK(display) ) { 1267 SDL_UnlockSurface(display); 1268 } 1269 if ( stretch ) { 1270 display = swdata->display; 1271 SDL_SoftStretch(swdata->stretch, src, display, dst); 1272 } 1273 SDL_UpdateRects(display, 1, dst); 1274 1275 return(0); 1276 } 1277 1278 void SDL_FreeYUV_SW(_THIS, SDL_Overlay *overlay) 1279 { 1280 struct private_yuvhwdata *swdata; 1281 1282 swdata = overlay->hwdata; 1283 if ( swdata ) { 1284 if ( swdata->stretch ) { 1285 SDL_FreeSurface(swdata->stretch); 1286 } 1287 if ( swdata->pixels ) { 1288 SDL_free(swdata->pixels); 1289 } 1290 if ( swdata->colortab ) { 1291 SDL_free(swdata->colortab); 1292 } 1293 if ( swdata->rgb_2_pix ) { 1294 SDL_free(swdata->rgb_2_pix); 1295 } 1296 SDL_free(swdata); 1297 overlay->hwdata = NULL; 1298 } 1299 } 1300
