openMSX
MLAAScaler.cc
Go to the documentation of this file.
1 #include "MLAAScaler.hh"
2 #include "FrameSource.hh"
3 #include "ScalerOutput.hh"
4 #include "MemBuffer.hh"
5 #include "aligned.hh"
6 #include "vla.hh"
7 #include "build-info.hh"
8 #include <algorithm>
9 #include <vector>
10 #include <cassert>
11 #include <cstdint>
12 
13 namespace openmsx {
14 
15 template<typename Pixel>
16 MLAAScaler<Pixel>::MLAAScaler(
17  unsigned dstWidth_, const PixelOperations<Pixel>& pixelOps_)
18  : pixelOps(pixelOps_)
19  , dstWidth(dstWidth_)
20 {
21 }
22 
23 template<typename Pixel>
24 void MLAAScaler<Pixel>::scaleImage(
25  FrameSource& src, const RawFrame* superImpose,
26  unsigned srcStartY, unsigned srcEndY, unsigned srcWidth,
27  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
28 {
29  (void)superImpose; // TODO: Support superimpose.
30  //fprintf(stderr, "scale line [%d..%d) to [%d..%d), width %d to %d\n",
31  // srcStartY, srcEndY, dstStartY, dstEndY, srcWidth, dstWidth);
32 
33  // TODO: Support non-integer zoom factors.
34  const unsigned zoomFactorX = dstWidth / srcWidth;
35  const unsigned zoomFactorY = (dstEndY - dstStartY) / (srcEndY - srcStartY);
36 
37  // Retrieve line pointers.
38  // We allow lookups one line before and after the scaled area.
39  // This is not just a trick to avoid range checks: to properly handle
40  // pixels at the top/bottom of the display area we must compare them to
41  // the border color.
42  const int srcNumLines = srcEndY - srcStartY;
43  VLA(const Pixel*, srcLinePtrsArray, srcNumLines + 2);
44  auto** srcLinePtrs = &srcLinePtrsArray[1];
45  std::vector<MemBuffer<Pixel, SSE_ALIGNMENT>> workBuffer;
46  const Pixel* line = nullptr;
47  Pixel* work = nullptr;
48  for (auto y : xrange(-1, srcNumLines + 1)) {
49  if (line == work) {
50  // Allocate new workBuffer when needed
51  // e.g. when used in previous iteration
52  work = workBuffer.emplace_back(srcWidth).data();
53  }
54  line = src.getLinePtr(srcStartY + y, srcWidth, work);
55  srcLinePtrs[y] = line;
56  }
57 
58  enum { UP = 1 << 0, RIGHT = 1 << 1, DOWN = 1 << 2, LEFT = 1 << 3 };
59  MemBuffer<uint8_t> edges(srcNumLines * srcWidth);
60  uint8_t* edgeGenPtr = edges.data();
61  for (auto y : xrange(srcNumLines)) {
62  auto* srcLinePtr = srcLinePtrs[y];
63  for (auto x : xrange(srcWidth)) {
64  Pixel colMid = srcLinePtr[x];
65  uint8_t pixEdges = 0;
66  if (x > 0 && srcLinePtr[x - 1] != colMid) {
67  pixEdges |= LEFT;
68  }
69  if (x < srcWidth - 1 && srcLinePtr[x + 1] != colMid) {
70  pixEdges |= RIGHT;
71  }
72  if (srcLinePtrs[y - 1][x] != colMid) {
73  pixEdges |= UP;
74  }
75  if (srcLinePtrs[y + 1][x] != colMid) {
76  pixEdges |= DOWN;
77  }
78  *edgeGenPtr++ = pixEdges;
79  }
80  }
81 
82  enum {
83  // Is this pixel part of an edge?
84  // And if so, where on the edge is it?
85  EDGE_START = 3 << 28,
86  EDGE_END = 2 << 28,
87  EDGE_INNER = 1 << 28,
88  EDGE_NONE = 0 << 28,
89  EDGE_MASK = 3 << 28,
90  // Is the edge is part of one or more slopes?
91  // And if so, what is the direction of the slope(s)?
92  SLOPE_TOP_LEFT = 1 << 27,
93  SLOPE_TOP_RIGHT = 1 << 26,
94  SLOPE_BOT_LEFT = 1 << 25,
95  SLOPE_BOT_RIGHT = 1 << 24,
96  // How long is this edge?
97  // For the start and end, these bits contain the length.
98  // For inner pixels, these bits contain the distance to the start pixel.
99  SPAN_BITS = 12,
100  SPAN_SHIFT_1 = 0,
101  SPAN_SHIFT_2 = SPAN_SHIFT_1 + SPAN_BITS,
102  SPAN_MASK = (1 << SPAN_BITS) - 1,
103  };
104  assert(srcWidth <= SPAN_MASK);
105 
106  // Find horizontal edges.
107  MemBuffer<unsigned> horizontals(srcNumLines * srcWidth);
108  unsigned* horizontalGenPtr = horizontals.data();
109  const uint8_t* edgePtr = edges.data();
110  for (auto y : xrange(srcNumLines)) {
111  unsigned x = 0;
112  while (x < srcWidth) {
113  // Check which corners are part of a slope.
114  bool slopeTopLeft = false;
115  bool slopeTopRight = false;
116  bool slopeBotLeft = false;
117  bool slopeBotRight = false;
118 
119  // Search for slopes on the top edge.
120  unsigned topEndX = x + 1;
121  // TODO: Making the slopes end in the middle of the edge segment
122  // is simple but inaccurate. Can we do better?
123  // Four cases:
124  // -- no slope
125  // /- left slope
126  // -\ right slope
127  // /\ U-shape
128  if (edgePtr[x] & UP) {
129  while (topEndX < srcWidth
130  && (edgePtr[topEndX] & (UP | LEFT)) == UP) topEndX++;
131  slopeTopLeft = (edgePtr[x] & LEFT)
132  && srcLinePtrs[y + 1][x - 1] == srcLinePtrs[y][x]
133  && srcLinePtrs[y][x - 1] == srcLinePtrs[y - 1][x];
134  slopeTopRight = (edgePtr[topEndX - 1] & RIGHT)
135  && srcLinePtrs[y + 1][topEndX] == srcLinePtrs[y][topEndX - 1]
136  && srcLinePtrs[y][topEndX] == srcLinePtrs[y - 1][topEndX - 1];
137  }
138 
139  // Search for slopes on the bottom edge.
140  unsigned botEndX = x + 1;
141  if (edgePtr[x] & DOWN) {
142  while (botEndX < srcWidth
143  && (edgePtr[botEndX] & (DOWN | LEFT)) == DOWN) botEndX++;
144  slopeBotLeft = (edgePtr[x] & LEFT)
145  && srcLinePtrs[y - 1][x - 1] == srcLinePtrs[y][x]
146  && srcLinePtrs[y][x - 1] == srcLinePtrs[y + 1][x];
147  slopeBotRight = (edgePtr[botEndX - 1] & RIGHT)
148  && srcLinePtrs[y - 1][botEndX] == srcLinePtrs[y][botEndX - 1]
149  && srcLinePtrs[y][botEndX] == srcLinePtrs[y + 1][botEndX - 1];
150  }
151 
152  // Store info about edge and determine next pixel to check.
153  if (!(slopeTopLeft || slopeTopRight ||
154  slopeBotLeft || slopeBotRight)) {
155  *horizontalGenPtr++ = EDGE_NONE;
156  x++;
157  } else {
158  unsigned slopes =
159  (slopeTopLeft ? SLOPE_TOP_LEFT : 0)
160  | (slopeTopRight ? SLOPE_TOP_RIGHT : 0)
161  | (slopeBotLeft ? SLOPE_BOT_LEFT : 0)
162  | (slopeBotRight ? SLOPE_BOT_RIGHT : 0);
163  const unsigned lengths =
164  ((topEndX - x) << SPAN_SHIFT_1) |
165  ((botEndX - x) << SPAN_SHIFT_2);
166  // Determine edge start and end points.
167  assert(!slopeTopRight || !slopeBotRight || topEndX == botEndX);
168  const unsigned endX = slopeTopRight ? topEndX : (
169  slopeBotRight ? botEndX : std::max(topEndX, botEndX)
170  );
171  const unsigned length = endX - x;
172  if (length == 1) {
173  *horizontalGenPtr++ = EDGE_START | EDGE_END | slopes | lengths;
174  } else {
175  *horizontalGenPtr++ = EDGE_START | slopes | lengths;
176  for (auto i : xrange(1u, length - 1)) {
177  *horizontalGenPtr++ = EDGE_INNER | slopes | i;
178  }
179  *horizontalGenPtr++ = EDGE_END | slopes | lengths;
180  }
181  x = endX;
182  }
183  }
184  assert(x == srcWidth);
185  edgePtr += srcWidth;
186  }
187  assert(unsigned(edgePtr - edges.data()) == srcNumLines * srcWidth);
188  assert(unsigned(horizontalGenPtr - horizontals.data()) == srcNumLines * srcWidth);
189 
190  // Find vertical edges.
191  MemBuffer<unsigned> verticals(srcNumLines * srcWidth);
192  edgePtr = edges.data();
193  for (auto x : xrange(srcWidth)) {
194  unsigned* verticalGenPtr = &verticals[x];
195  int y = 0;
196  while (y < srcNumLines) {
197  // Check which corners are part of a slope.
198  bool slopeTopLeft = false;
199  bool slopeTopRight = false;
200  bool slopeBotLeft = false;
201  bool slopeBotRight = false;
202 
203  // Search for slopes on the left edge.
204  int leftEndY = y + 1;
205  if (edgePtr[y * srcWidth] & LEFT) {
206  while (leftEndY < srcNumLines
207  && (edgePtr[leftEndY * srcWidth] & (LEFT | UP)) == LEFT) leftEndY++;
208  assert(x > 0); // implied by having a left edge
209  const unsigned nextX = std::min(x + 1, srcWidth - 1);
210  slopeTopLeft = (edgePtr[y * srcWidth] & UP)
211  && srcLinePtrs[y - 1][nextX] == srcLinePtrs[y][x]
212  && srcLinePtrs[y - 1][x] == srcLinePtrs[y][x - 1];
213  slopeBotLeft = (edgePtr[(leftEndY - 1) * srcWidth] & DOWN)
214  && srcLinePtrs[leftEndY][nextX] == srcLinePtrs[leftEndY - 1][x]
215  && srcLinePtrs[leftEndY][x] == srcLinePtrs[leftEndY - 1][x - 1];
216  }
217 
218  // Search for slopes on the right edge.
219  int rightEndY = y + 1;
220  if (edgePtr[y * srcWidth] & RIGHT) {
221  while (rightEndY < srcNumLines
222  && (edgePtr[rightEndY * srcWidth] & (RIGHT | UP)) == RIGHT) rightEndY++;
223  assert(x < srcWidth); // implied by having a right edge
224  const unsigned prevX = x == 0 ? 0 : x - 1;
225  slopeTopRight = (edgePtr[y * srcWidth] & UP)
226  && srcLinePtrs[y - 1][prevX] == srcLinePtrs[y][x]
227  && srcLinePtrs[y - 1][x] == srcLinePtrs[y][x + 1];
228  slopeBotRight = (edgePtr[(rightEndY - 1) * srcWidth] & DOWN)
229  && srcLinePtrs[rightEndY][prevX] == srcLinePtrs[rightEndY - 1][x]
230  && srcLinePtrs[rightEndY][x] == srcLinePtrs[rightEndY - 1][x + 1];
231  }
232 
233  // Store info about edge and determine next pixel to check.
234  if (!(slopeTopLeft || slopeTopRight ||
235  slopeBotLeft || slopeBotRight)) {
236  *verticalGenPtr = EDGE_NONE;
237  verticalGenPtr += srcWidth;
238  y++;
239  } else {
240  unsigned slopes =
241  (slopeTopLeft ? SLOPE_TOP_LEFT : 0)
242  | (slopeTopRight ? SLOPE_TOP_RIGHT : 0)
243  | (slopeBotLeft ? SLOPE_BOT_LEFT : 0)
244  | (slopeBotRight ? SLOPE_BOT_RIGHT : 0);
245  const unsigned lengths =
246  ((leftEndY - y) << SPAN_SHIFT_1) |
247  ((rightEndY - y) << SPAN_SHIFT_2);
248  // Determine edge start and end points.
249  assert(!slopeBotLeft || !slopeBotRight || leftEndY == rightEndY);
250  const unsigned endY = slopeBotLeft ? leftEndY : (
251  slopeBotRight ? rightEndY : std::max(leftEndY, rightEndY)
252  );
253  const unsigned length = endY - y;
254  if (length == 1) {
255  *verticalGenPtr = EDGE_START | EDGE_END | slopes | lengths;
256  verticalGenPtr += srcWidth;
257  } else {
258  *verticalGenPtr = EDGE_START | slopes | lengths;
259  verticalGenPtr += srcWidth;
260  for (auto i : xrange(1u, length - 1)) {
261  // TODO: To be fully accurate we need to have separate
262  // start/stop points for the two possible edges
263  // of this pixel. No code uses the inner info yet
264  // though, so this can be fixed later.
265  *verticalGenPtr = EDGE_INNER | slopes | i;
266  verticalGenPtr += srcWidth;
267  }
268  *verticalGenPtr = EDGE_END | slopes | lengths;
269  verticalGenPtr += srcWidth;
270  }
271  y = endY;
272  }
273  }
274  assert(y == srcNumLines);
275  assert(unsigned(verticalGenPtr - verticals.data()) == x + srcNumLines * srcWidth);
276  edgePtr++;
277  }
278  assert(unsigned(edgePtr - edges.data()) == srcWidth);
279 
280  VLA(Pixel*, dstLines, dst.getHeight());
281  for (auto i : xrange(dstStartY, dstEndY)) {
282  dstLines[i] = dst.acquireLine(i);
283  }
284 
285  // Do a mosaic scale so every destination pixel has a color.
286  unsigned dstY = dstStartY;
287  for (auto y : xrange(srcNumLines)) {
288  auto* srcLinePtr = srcLinePtrs[y];
289  for (auto x : xrange(srcWidth)) {
290  Pixel col = srcLinePtr[x];
291  for (auto iy : xrange(zoomFactorY)) {
292  for (auto ix : xrange(zoomFactorX)) {
293  dstLines[dstY + iy][x * zoomFactorX + ix] = col;
294  }
295  }
296  }
297  dstY += zoomFactorY;
298  }
299 
300  // Render the horizontal edges.
301  const unsigned* horizontalPtr = horizontals.data();
302  dstY = dstStartY;
303  for (auto y : xrange(srcNumLines)) {
304  unsigned x = 0;
305  while (x < srcWidth) {
306  // Fetch information about the edge, if any, at the current pixel.
307  unsigned horzInfo = *horizontalPtr;
308  if ((horzInfo & EDGE_MASK) == EDGE_NONE) {
309  x++;
310  horizontalPtr++;
311  continue;
312  }
313  assert((horzInfo & EDGE_MASK) == EDGE_START);
314 
315  // Check which corners are part of a slope.
316  bool slopeTopLeft = (horzInfo & SLOPE_TOP_LEFT ) != 0;
317  bool slopeTopRight = (horzInfo & SLOPE_TOP_RIGHT) != 0;
318  bool slopeBotLeft = (horzInfo & SLOPE_BOT_LEFT ) != 0;
319  bool slopeBotRight = (horzInfo & SLOPE_BOT_RIGHT) != 0;
320  const unsigned startX = x;
321  const unsigned topEndX =
322  startX + ((horzInfo >> SPAN_SHIFT_1) & SPAN_MASK);
323  const unsigned botEndX =
324  startX + ((horzInfo >> SPAN_SHIFT_2) & SPAN_MASK);
325  // Determine edge start and end points.
326  assert(!slopeTopRight || !slopeBotRight || topEndX == botEndX);
327  const unsigned endX = slopeTopRight ? topEndX : (
328  slopeBotRight ? botEndX : std::max(topEndX, botEndX)
329  );
330  x = endX;
331  horizontalPtr += endX - startX;
332 
333  // Antialias either the top or the bottom, but not both.
334  // TODO: Figure out what the best way is to handle these situations.
335  if (slopeTopLeft && slopeBotLeft) {
336  slopeTopLeft = slopeBotLeft = false;
337  }
338  if (slopeTopRight && slopeBotRight) {
339  slopeTopRight = slopeBotRight = false;
340  }
341 
342  // Render slopes.
343  auto* srcTopLinePtr = srcLinePtrs[y - 1];
344  auto* srcCurLinePtr = srcLinePtrs[y + 0];
345  auto* srcBotLinePtr = srcLinePtrs[y + 1];
346  const unsigned x0 = startX * 2 * zoomFactorX;
347  const unsigned x1 =
348  slopeTopLeft
349  ? (startX + topEndX) * zoomFactorX
350  : (slopeBotLeft
351  ? (startX + botEndX) * zoomFactorX
352  : x0);
353  const unsigned x3 = endX * 2 * zoomFactorX;
354  const unsigned x2 =
355  slopeTopRight
356  ? (startX + topEndX) * zoomFactorX
357  : (slopeBotRight
358  ? (startX + botEndX) * zoomFactorX
359  : x3);
360  for (auto iy : xrange(zoomFactorY)) {
361  auto* dstLinePtr = dstLines[dstY + iy];
362 
363  // Figure out which parts of the line should be blended.
364  bool blendTopLeft = false;
365  bool blendTopRight = false;
366  bool blendBotLeft = false;
367  bool blendBotRight = false;
368  if (iy * 2 < zoomFactorY) {
369  blendTopLeft = slopeTopLeft;
370  blendTopRight = slopeTopRight;
371  }
372  if (iy * 2 + 1 >= zoomFactorY) {
373  blendBotLeft = slopeBotLeft;
374  blendBotRight = slopeBotRight;
375  }
376 
377  // Render left side.
378  if (blendTopLeft || blendBotLeft) {
379  // TODO: This is implied by !(slopeTopLeft && slopeBotLeft),
380  // which is ensured by a temporary measure.
381  assert(!(blendTopLeft && blendBotLeft));
382  const Pixel* srcMixLinePtr = blendTopLeft
383  ? srcTopLinePtr
384  : srcBotLinePtr;
385  float lineY = blendTopLeft
386  ? ((zoomFactorY - 1 - iy) / float(zoomFactorY))
387  : (iy / float(zoomFactorY));
388  for (unsigned fx = x0 | 1; fx < x1; fx += 2) {
389  float rx = (fx - x0) / float(x1 - x0);
390  float ry = 0.5f + rx * 0.5f;
391  float weight = (ry - lineY) * zoomFactorY;
392  dstLinePtr[fx / 2] = pixelOps.lerp(
393  srcMixLinePtr[fx / (zoomFactorX * 2)],
394  srcCurLinePtr[fx / (zoomFactorX * 2)],
395  std::clamp(int(256 * weight), 0, 256));
396  }
397  }
398 
399  // Render right side.
400  if (blendTopRight || blendBotRight) {
401  // TODO: This is implied by !(slopeTopRight && slopeBotRight),
402  // which is ensured by a temporary measure.
403  assert(!(blendTopRight && blendBotRight));
404  const Pixel* srcMixLinePtr = blendTopRight
405  ? srcTopLinePtr
406  : srcBotLinePtr;
407  float lineY = blendTopRight
408  ? ((zoomFactorY - 1 - iy) / float(zoomFactorY))
409  : (iy / float(zoomFactorY));
410  // TODO: The weight is slightly too high for the middle
411  // pixel when zoomFactorX is odd and we are rendering
412  // a U-shape.
413  for (unsigned fx = x2 | 1; fx < x3; fx += 2) {
414  float rx = (fx - x2) / float(x3 - x2);
415  float ry = 1.0f - rx * 0.5f;
416  float weight = (ry - lineY) * zoomFactorY;
417  dstLinePtr[fx / 2] = pixelOps.lerp(
418  srcMixLinePtr[fx / (zoomFactorX * 2)],
419  srcCurLinePtr[fx / (zoomFactorX * 2)],
420  std::clamp(int(256 * weight), 0, 256));
421  }
422  }
423 
424  // Draw horizontal edge indicators.
425  if (false) {
426  if (iy == 0) {
427  if (slopeTopLeft) {
428  for (unsigned fx = x0 | 1; fx < x1; fx += 2) {
429  dstLinePtr[fx / 2] =
430  pixelOps.combine256(255, 0, 0);
431  }
432  }
433  if (slopeTopRight) {
434  for (unsigned fx = x2 | 1; fx < x3; fx += 2) {
435  dstLinePtr[fx / 2] =
436  pixelOps.combine256(0, 0, 255);
437  }
438  }
439  } else if (iy == zoomFactorY - 1) {
440  if (slopeBotLeft) {
441  for (unsigned fx = x0 | 1; fx < x1; fx += 2) {
442  dstLinePtr[fx / 2] =
443  pixelOps.combine256(255, 255, 0);
444  }
445  }
446  if (slopeBotRight) {
447  for (unsigned fx = x2 | 1; fx < x3; fx += 2) {
448  dstLinePtr[fx / 2] =
449  pixelOps.combine256(0, 255, 0);
450  }
451  }
452  }
453  }
454  }
455  }
456  assert(x == srcWidth);
457  dstY += zoomFactorY;
458  }
459  assert(unsigned(horizontalPtr - horizontals.data()) == srcNumLines * srcWidth);
460 
461  // Render the vertical edges.
462  for (auto x : xrange(srcWidth)) {
463  const unsigned* verticalPtr = &verticals[x];
464  int y = 0;
465  while (y < srcNumLines) {
466  // Fetch information about the edge, if any, at the current pixel.
467  unsigned vertInfo = *verticalPtr;
468  if ((vertInfo & EDGE_MASK) == EDGE_NONE) {
469  y++;
470  verticalPtr += srcWidth;
471  continue;
472  }
473  assert((vertInfo & EDGE_MASK) == EDGE_START);
474 
475  // Check which corners are part of a slope.
476  bool slopeTopLeft = (vertInfo & SLOPE_TOP_LEFT ) != 0;
477  bool slopeTopRight = (vertInfo & SLOPE_TOP_RIGHT) != 0;
478  bool slopeBotLeft = (vertInfo & SLOPE_BOT_LEFT ) != 0;
479  bool slopeBotRight = (vertInfo & SLOPE_BOT_RIGHT) != 0;
480  const unsigned startY = y;
481  const unsigned leftEndY =
482  startY + ((vertInfo >> SPAN_SHIFT_1) & SPAN_MASK);
483  const unsigned rightEndY =
484  startY + ((vertInfo >> SPAN_SHIFT_2) & SPAN_MASK);
485  // Determine edge start and end points.
486  assert(!slopeBotLeft || !slopeBotRight || leftEndY == rightEndY);
487  const unsigned endY = slopeBotLeft ? leftEndY : (
488  slopeBotRight ? rightEndY : std::max(leftEndY, rightEndY)
489  );
490  y = endY;
491  verticalPtr += srcWidth * (endY - startY);
492 
493  // Antialias either the left or the right, but not both.
494  if (slopeTopLeft && slopeTopRight) {
495  slopeTopLeft = slopeTopRight = false;
496  }
497  if (slopeBotLeft && slopeBotRight) {
498  slopeBotLeft = slopeBotRight = false;
499  }
500 
501  // Render slopes.
502  const unsigned leftX = x == 0 ? 0 : x - 1;
503  const unsigned curX = x;
504  const unsigned rightX = std::min(x + 1, srcWidth - 1);
505  const unsigned y0 = startY * 2 * zoomFactorY;
506  const unsigned y1 =
507  slopeTopLeft
508  ? (startY + leftEndY) * zoomFactorY
509  : (slopeTopRight
510  ? (startY + rightEndY) * zoomFactorY
511  : y0);
512  const unsigned y3 = endY * 2 * zoomFactorY;
513  const unsigned y2 =
514  slopeBotLeft
515  ? (startY + leftEndY) * zoomFactorY
516  : (slopeBotRight
517  ? (startY + rightEndY) * zoomFactorY
518  : y3);
519  for (auto ix : xrange(zoomFactorX)) {
520  const unsigned fx = x * zoomFactorX + ix;
521 
522  // Figure out which parts of the line should be blended.
523  bool blendTopLeft = false;
524  bool blendTopRight = false;
525  bool blendBotLeft = false;
526  bool blendBotRight = false;
527  if (ix * 2 < zoomFactorX) {
528  blendTopLeft = slopeTopLeft;
529  blendBotLeft = slopeBotLeft;
530  }
531  if (ix * 2 + 1 >= zoomFactorX) {
532  blendTopRight = slopeTopRight;
533  blendBotRight = slopeBotRight;
534  }
535 
536  // Render top side.
537  if (blendTopLeft || blendTopRight) {
538  assert(!(blendTopLeft && blendTopRight));
539  unsigned mixX = blendTopLeft ? leftX : rightX;
540  float lineX = blendTopLeft
541  ? ((zoomFactorX - 1 - ix) / float(zoomFactorX))
542  : (ix / float(zoomFactorX));
543  for (unsigned fy = y0 | 1; fy < y1; fy += 2) {
544  auto* dstLinePtr = dstLines[dstStartY + fy / 2];
545  float ry = (fy - y0) / float(y1 - y0);
546  float rx = 0.5f + ry * 0.5f;
547  float weight = (rx - lineX) * zoomFactorX;
548  dstLinePtr[fx] = pixelOps.lerp(
549  srcLinePtrs[fy / (zoomFactorY * 2)][mixX],
550  srcLinePtrs[fy / (zoomFactorY * 2)][curX],
551  std::clamp(int(256 * weight), 0, 256));
552  }
553  }
554 
555  // Render bottom side.
556  if (blendBotLeft || blendBotRight) {
557  assert(!(blendBotLeft && blendBotRight));
558  unsigned mixX = blendBotLeft ? leftX : rightX;
559  float lineX = blendBotLeft
560  ? ((zoomFactorX - 1 - ix) / float(zoomFactorX))
561  : (ix / float(zoomFactorX));
562  for (unsigned fy = y2 | 1; fy < y3; fy += 2) {
563  auto* dstLinePtr = dstLines[dstStartY + fy / 2];
564  float ry = (fy - y2) / float(y3 - y2);
565  float rx = 1.0f - ry * 0.5f;
566  float weight = (rx - lineX) * zoomFactorX;
567  dstLinePtr[fx] = pixelOps.lerp(
568  srcLinePtrs[fy / (zoomFactorY * 2)][mixX],
569  srcLinePtrs[fy / (zoomFactorY * 2)][curX],
570  std::clamp(int(256 * weight), 0, 256));
571  }
572  }
573 
574  // Draw vertical edge indicators.
575  if (false) {
576  if (ix == 0) {
577  if (slopeTopLeft) {
578  for (unsigned fy = y0 | 1; fy < y1; fy += 2) {
579  auto* dstLinePtr = dstLines[
580  dstStartY + fy / 2];
581  dstLinePtr[fx] =
582  pixelOps.combine256(255, 0, 0);
583  }
584  }
585  if (slopeBotLeft) {
586  for (unsigned fy = y2 | 1; fy < y3; fy += 2) {
587  auto* dstLinePtr = dstLines[
588  dstStartY + fy / 2];
589  dstLinePtr[fx] =
590  pixelOps.combine256(255, 255, 0);
591  }
592  }
593  } else if (ix == zoomFactorX - 1) {
594  if (slopeTopRight) {
595  for (unsigned fy = y0 | 1; fy < y1; fy += 2) {
596  auto* dstLinePtr = dstLines[
597  dstStartY + fy / 2];
598  dstLinePtr[fx] =
599  pixelOps.combine256(0, 0, 255);
600  }
601  }
602  if (slopeBotRight) {
603  for (unsigned fy = y2 | 1; fy < y3; fy += 2) {
604  auto* dstLinePtr = dstLines[
605  dstStartY + fy / 2];
606  dstLinePtr[fx] =
607  pixelOps.combine256(0, 255, 0);
608  }
609  }
610  }
611  }
612  }
613  }
614  assert(y == srcNumLines);
615  }
616 
617  // TODO: This is compensation for the fact that we do not support
618  // non-integer zoom factors yet.
619  if (srcWidth * zoomFactorX != dstWidth) {
620  for (auto dy : xrange(dstStartY, dstY)) {
621  unsigned sy = std::min(
622  (dy - dstStartY) / zoomFactorY - srcStartY,
623  unsigned(srcNumLines)
624  );
625  Pixel col = srcLinePtrs[sy][srcWidth - 1];
626  for (auto dx : xrange(srcWidth * zoomFactorX, dstWidth)) {
627  dstLines[dy][dx] = col;
628  }
629  }
630  }
631  if (dstY != dstEndY) {
632  // Typically this will pick the border color, but there is no guarantee.
633  // However, we're inside a workaround anyway, so it's good enough.
634  Pixel col = srcLinePtrs[srcNumLines - 1][srcWidth - 1];
635  for (auto dy : xrange(dstY, dstEndY)) {
636  for (auto dx : xrange(dstWidth)) {
637  dstLines[dy][dx] = col;
638  }
639  }
640  }
641 
642  for (auto i : xrange(dstStartY, dstEndY)) {
643  dst.releaseLine(i, dstLines[i]);
644  }
645 }
646 
647 // Force template instantiation.
648 #if HAVE_16BPP
649 template class MLAAScaler<uint16_t>;
650 #endif
651 #if HAVE_32BPP
652 template class MLAAScaler<uint32_t>;
653 #endif
654 
655 } // namespace openmsx
openmsx::FrameSource
Interface for getting lines from a video frame.
Definition: FrameSource.hh:15
openmsx::FrameSource::getLinePtr
const Pixel * getLinePtr(int line, unsigned width, Pixel *buf) const
Gets a pointer to the pixels of the given line number.
Definition: FrameSource.hh:91
openmsx::MLAAScaler
Scaler that uses a variation of the morphological anti-aliasing algorithm.
Definition: MLAAScaler.hh:20
openmsx::MLAAScaler::scaleImage
void scaleImage(FrameSource &src, const RawFrame *superImpose, unsigned srcStartY, unsigned srcEndY, unsigned srcWidth, ScalerOutput< Pixel > &dst, unsigned dstStartY, unsigned dstEndY) override
Scales the image in the given area, which must consist of lines which are all equally wide.
Definition: MLAAScaler.cc:24
openmsx::MLAAScaler::MLAAScaler
MLAAScaler(unsigned dstWidth, const PixelOperations< Pixel > &pixelOps)
Definition: MLAAScaler.cc:16
openmsx::MemBuffer::data
const T * data() const
Returns pointer to the start of the memory buffer.
Definition: MemBuffer.hh:81
openmsx::RawFrame
A video frame as output by the VDP scanline conversion unit, before any postprocessing filters are ap...
Definition: RawFrame.hh:14
openmsx::ScalerOutput::acquireLine
virtual Pixel * acquireLine(unsigned y)=0
openmsx::ScalerOutput::getHeight
virtual unsigned getHeight() const =0
openmsx::ScalerOutput::releaseLine
virtual void releaseLine(unsigned y, Pixel *buf)=0
gl::min
constexpr vecN< N, T > min(const vecN< N, T > &x, const vecN< N, T > &y)
Definition: gl_vec.hh:269
gl::length
T length(const vecN< N, T > &x)
Definition: gl_vec.hh:343
gl::max
constexpr vecN< N, T > max(const vecN< N, T > &x, const vecN< N, T > &y)
Definition: gl_vec.hh:287
gl::clamp
constexpr vecN< N, T > clamp(const vecN< N, T > &x, const vecN< N, T > &minVal, const vecN< N, T > &maxVal)
Definition: gl_vec.hh:296
openmsx
This file implemented 3 utility functions:
Definition: Autofire.cc:5
openmsx::Pixel
uint32_t Pixel
Definition: GLHQLiteScaler.cc:98
openmsx::x
constexpr KeyMatrixPosition x
Keyboard bindings.
Definition: Keyboard.cc:124
VLA
#define VLA(TYPE, NAME, LENGTH)
Definition: vla.hh:10
xrange
constexpr auto xrange(T e)
Definition: xrange.hh:155
Generated on Sat Apr 10 2021 17:13:16 for openMSX by doxygen 1.9.1