Ignore:
Timestamp:
Jun 5, 2006, 4:02:32 PM (16 years ago)
Author:
Eugene Romanenko
Message:

poppler updated to version 0.5.3, related changes

Location:
trunk/poppler/mypoppler/splash
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/mypoppler/splash/Splash.cc

    r27 r44  
    308308  case splashModeRGB8:
    309309  case splashModeBGR8:
     310    if (color[0] == color[1] && color[1] == color[2]) {
     311      if (bitmap->rowSize < 0) {
     312        memset(bitmap->data + bitmap->rowSize * (bitmap->height - 1),
     313               color[0], -bitmap->rowSize * bitmap->height);
     314      } else {
     315        memset(bitmap->data, color[0], bitmap->rowSize * bitmap->height);
     316      }
     317    } else {
     318      row = bitmap->data;
     319      for (y = 0; y < bitmap->height; ++y) {
     320        p = row;
     321        for (x = 0; x < bitmap->width; ++x) {
     322          *p++ = color[0];
     323          *p++ = color[1];
     324          *p++ = color[2];
     325        }
     326        row += bitmap->rowSize;
     327      }
     328    }
     329    break;
     330  case splashModeRGB8Qt:
    310331    if (color[0] == color[1] && color[1] == color[2]) {
    311332      if (bitmap->rowSize < 0) {
     
    965986      case splashModeRGB8:
    966987      case splashModeBGR8:
     988        p = &bitmap->data[y * bitmap->rowSize + 3 * x];
     989        (*blendFunc)(color, p, blend, bitmap->mode);
     990        p[0] = (alpha2 * blend[0] + ialpha2 * p[0]) >> 8;
     991        p[1] = (alpha2 * blend[1] + ialpha2 * p[1]) >> 8;
     992        p[2] = (alpha2 * blend[2] + ialpha2 * p[2]) >> 8;
     993        break;
     994      case splashModeRGB8Qt:
    967995        p = &bitmap->data[y * bitmap->rowSize + 4 * x];
    968996        (*blendFunc)(color, p, blend, bitmap->mode);
     
    10161044      case splashModeRGB8:
    10171045      case splashModeBGR8:
     1046        p = &bitmap->data[y * bitmap->rowSize + 3 * x];
     1047        p[0] = color[0];
     1048        p[1] = color[1];
     1049        p[2] = color[2];
     1050        break;
     1051      case splashModeRGB8Qt:
    10181052        p = &bitmap->data[y * bitmap->rowSize + 4 * x];
    10191053        p[0] = color[2];
     
    10941128      case splashModeRGB8:
    10951129      case splashModeBGR8:
     1130        p = &bitmap->data[y * bitmap->rowSize + 3 * x];
     1131        (*blendFunc)(color, p, blend, bitmap->mode);
     1132        p[0] = (alpha2 * blend[0] + ialpha2 * p[0]) >> 8;
     1133        p[1] = (alpha2 * blend[1] + ialpha2 * p[1]) >> 8;
     1134        p[2] = (alpha2 * blend[2] + ialpha2 * p[2]) >> 8;
     1135        break;
     1136      case splashModeRGB8Qt:
    10961137        p = &bitmap->data[y * bitmap->rowSize + 4 * x];
    10971138        (*blendFunc)(color, p, blend, bitmap->mode);
     
    11461187      case splashModeRGB8:
    11471188      case splashModeBGR8:
     1189        p = &bitmap->data[y * bitmap->rowSize + 3 * x];
     1190        p[0] = color[0];
     1191        p[1] = color[1];
     1192        p[2] = color[2];
     1193        break;
     1194      case splashModeRGB8Qt:
    11481195        p = &bitmap->data[y * bitmap->rowSize + 4 * x];
    11491196        p[0] = color[2];
     
    14071454    case splashModeRGB8:
    14081455    case splashModeBGR8:
     1456      p = &bitmap->data[y * bitmap->rowSize + 3 * x0];
     1457      if (pattern->isStatic()) {
     1458        pattern->getColor(0, 0, color);
     1459        for (i = 0; i < n; ++i) {
     1460          if (noClip || state->clip->test(x0 + i, y)) {
     1461            if (softMask) {
     1462              alpha2 = (int)(alpha *
     1463                             softMask->data[y * softMask->rowSize + x0 + i]);
     1464              ialpha2 = 255 - alpha2;
     1465            }
     1466            (*blendFunc)(color, p, blend, bitmap->mode);
     1467            p[0] = (alpha2 * blend[0] + ialpha2 * p[0]) >> 8;
     1468            p[1] = (alpha2 * blend[1] + ialpha2 * p[1]) >> 8;
     1469            p[2] = (alpha2 * blend[2] + ialpha2 * p[2]) >> 8;
     1470            if (!noClip) {
     1471              updateModX(x0 + i);
     1472              updateModY(y);
     1473            }
     1474          }
     1475          p += 3;
     1476        }
     1477      } else {
     1478        for (i = 0; i < n; ++i) {
     1479          if (noClip || state->clip->test(x0 + i, y)) {
     1480            pattern->getColor(x0 + i, y, color);
     1481            if (softMask) {
     1482              alpha2 = (int)(alpha *
     1483                             softMask->data[y * softMask->rowSize + x0 + i]);
     1484              ialpha2 = 255 - alpha2;
     1485            }
     1486            (*blendFunc)(color, p, blend, bitmap->mode);
     1487            p[0] = (alpha2 * blend[0] + ialpha2 * p[0]) >> 8;
     1488            p[1] = (alpha2 * blend[1] + ialpha2 * p[1]) >> 8;
     1489            p[2] = (alpha2 * blend[2] + ialpha2 * p[2]) >> 8;
     1490            if (!noClip) {
     1491              updateModX(x0 + i);
     1492              updateModY(y);
     1493            }
     1494          }
     1495          p += 3;
     1496        }
     1497      }
     1498      break;
     1499
     1500    case splashModeRGB8Qt:
    14091501      p = &bitmap->data[y * bitmap->rowSize + 4 * x0];
    14101502      if (pattern->isStatic()) {
     
    17001792    case splashModeRGB8:
    17011793    case splashModeBGR8:
     1794      p = &bitmap->data[y * bitmap->rowSize + 3 * x0];
     1795      if (pattern->isStatic()) {
     1796        pattern->getColor(0, 0, color);
     1797        for (i = 0; i < n; ++i) {
     1798          if (noClip || state->clip->test(x0 + i, y)) {
     1799            p[0] = color[0];
     1800            p[1] = color[1];
     1801            p[2] = color[2];
     1802            if (!noClip) {
     1803              updateModX(x0 + i);
     1804              updateModY(y);
     1805            }
     1806          }
     1807          p += 3;
     1808        }
     1809      } else {
     1810        for (i = 0; i < n; ++i) {
     1811          if (noClip || state->clip->test(x0 + i, y)) {
     1812            pattern->getColor(x0 + i, y, color);
     1813            p[0] = color[0];
     1814            p[1] = color[1];
     1815            p[2] = color[2];
     1816            if (!noClip) {
     1817              updateModX(x0 + i);
     1818              updateModY(y);
     1819            }
     1820          }
     1821          p += 3;
     1822        }
     1823      }
     1824      break;
     1825
     1826    case splashModeRGB8Qt:
    17021827      p = &bitmap->data[y * bitmap->rowSize + 4 * x0];
    17031828      if (pattern->isStatic()) {
     
    19002025  case splashModeRGB8:
    19012026  case splashModeBGR8:
     2027    p = &bitmap->data[y * bitmap->rowSize + 3 * x0];
     2028    for (i = 0; i < n; ++i) {
     2029      if (noClip || state->clip->test(x0 + i, y)) {
     2030        pattern->getColor(x0 + i, y, color);
     2031        p[0] ^= color[0];
     2032        p[1] ^= color[1];
     2033        p[2] ^= color[2];
     2034        if (!noClip) {
     2035          updateModX(x0 + i);
     2036          updateModY(y);
     2037        }
     2038      }
     2039      p += 3;
     2040    }
     2041    break;
     2042
     2043  case splashModeRGB8Qt:
    19022044    p = &bitmap->data[y * bitmap->rowSize + 4 * x0];
    19032045    for (i = 0; i < n; ++i) {
     
    20572199                case splashModeRGB8:
    20582200                case splashModeBGR8:
     2201                  pix = &bitmap->data[y1 * bitmap->rowSize + 3 * x1];
     2202                  (*blendFunc)(fg, pix, blend, bitmap->mode);
     2203                  pix[0] = (alpha * blend[0] + ialpha * pix[0]) >> 8;
     2204                  pix[1] = (alpha * blend[1] + ialpha * pix[1]) >> 8;
     2205                  pix[2] = (alpha * blend[2] + ialpha * pix[2]) >> 8;
     2206                  break;
     2207                case splashModeRGB8Qt:
    20592208                  pix = &bitmap->data[y1 * bitmap->rowSize + 4 * x1];
    20602209                  (*blendFunc)(fg, pix, blend, bitmap->mode);
     
    21382287                  case splashModeRGB8:
    21392288                  case splashModeBGR8:
     2289                    pix = &bitmap->data[y1 * bitmap->rowSize + 3 * x1];
     2290                    (*blendFunc)(fg, pix, blend, bitmap->mode);
     2291                    pix[0] = (alpha * blend[0] + ialpha * pix[0]) >> 8;
     2292                    pix[1] = (alpha * blend[1] + ialpha * pix[1]) >> 8;
     2293                    pix[2] = (alpha * blend[2] + ialpha * pix[2]) >> 8;
     2294                    break;
     2295                  case splashModeRGB8Qt:
    21402296                    pix = &bitmap->data[y1 * bitmap->rowSize + 4 * x1];
    21412297                    (*blendFunc)(fg, pix, blend, bitmap->mode);
     
    22132369                case splashModeRGB8:
    22142370                case splashModeBGR8:
     2371                  pix = &bitmap->data[y1 * bitmap->rowSize + 3 * x1];
     2372                  pix[0] = (alpha * fg[0] + ialpha * pix[0]) >> 8;
     2373                  pix[1] = (alpha * fg[1] + ialpha * pix[1]) >> 8;
     2374                  pix[2] = (alpha * fg[2] + ialpha * pix[2]) >> 8;
     2375                  break;
     2376                case splashModeRGB8Qt:
    22152377                  pix = &bitmap->data[y1 * bitmap->rowSize + 4 * x1];
    22162378                  pix[0] = (alpha * fg[2] + ialpha * pix[0]) >> 8;
     
    22782440                  case splashModeRGB8:
    22792441                  case splashModeBGR8:
     2442                    pix = &bitmap->data[y1 * bitmap->rowSize + 3 * x1];
     2443                    pix[0] = fg[0];
     2444                    pix[1] = fg[1];
     2445                    pix[2] = fg[2];
     2446                    break;
     2447                  case splashModeRGB8Qt:
    22802448                    pix = &bitmap->data[y1 * bitmap->rowSize + 4 * x1];
    22812449                    pix[0] = fg[2];
     
    26352803    nComps = 2;
    26362804    break;
     2805  case splashModeRGB8Qt:
    26372806  case splashModeRGB8:
    26382807    ok = srcMode == splashModeRGB8 || srcMode == splashModeARGB8;
  • trunk/poppler/mypoppler/splash/SplashBitmap.cc

    r27 r44  
    3737  case splashModeRGB8:
    3838  case splashModeBGR8:
    39     rowSize = width * 4;
    40     break;
     39    rowSize = width * 3;
     40    break;
     41  case splashModeRGB8Qt:
    4142  case splashModeARGB8:
    4243  case splashModeBGRA8:
     
    129130        fputc(splashRGB8G(p), f);
    130131        fputc(splashRGB8B(p), f);
    131         p += 4;
     132        p += 3;
    132133      }
    133134      row += rowSize;
     
    150151    break;
    151152
     153 case splashModeRGB8Qt:
     154    fprintf(f, "P6\n%d %d\n255\n", width, height);
     155    row = data;
     156    for (y = 0; y < height; ++y) {
     157      p = row;
     158      for (x = 0; x < width; ++x) {
     159        fputc(splashRGB8R(p), f);
     160        fputc(splashRGB8G(p), f);
     161        fputc(splashRGB8B(p), f);
     162        p += 4;
     163      }
     164      row += rowSize;
     165    }
     166    break;
     167
    152168  case splashModeARGB8:
    153169    fprintf(f, "P6\n%d %d\n255\n", width, height);
     
    214230  case splashModeRGB8:
    215231  case splashModeBGR8:
     232    p = &data[y * rowSize + 3 * x];
     233    pixel[0] = p[0];
     234    pixel[1] = p[1];
     235    pixel[2] = p[2];
     236    break;
     237  case splashModeRGB8Qt:
    216238    p = &data[y * rowSize + 4 * x];
    217239    pixel[0] = p[2];
  • trunk/poppler/mypoppler/splash/SplashTypes.h

    r2 r44  
    3737  splashModeARGB8,              // 1 byte per component, 4 bytes per pixel:
    3838                                //   ARGBARGB...
     39  splashModeRGB8Qt,             // 1 byte per component, 4 bytes per pixel:
     40                                //   Specially hacked to use in Qt frontends
    3941  splashModeBGRA8               // 1 byte per component, 4 bytes per pixel:
    4042                                //   BGRABGRA...
Note: See TracChangeset for help on using the changeset viewer.