openMSX
RGBTriplet3xScaler.cc
Go to the documentation of this file.
1 #include "RGBTriplet3xScaler.hh"
3 #include "LineScalers.hh"
4 #include "RawFrame.hh"
5 #include "ScalerOutput.hh"
6 #include "RenderSettings.hh"
7 #include "vla.hh"
8 #include "build-info.hh"
9 #include <cstdint>
10 
11 namespace openmsx {
12 
13 template<typename Pixel>
15  const PixelOperations<Pixel>& pixelOps_,
16  const RenderSettings& renderSettings)
17  : Scaler3<Pixel>(pixelOps_)
18  , pixelOps(pixelOps_)
19  , scanline(pixelOps_)
20  , settings(renderSettings)
21 {
22 }
23 
24 template<typename Pixel>
25 std::pair<unsigned, unsigned> RGBTriplet3xScaler<Pixel>::calcBlur()
26 {
27  unsigned c1 = settings.getBlurFactor();
28  unsigned c2 = (3 * 256) - (2 * c1);
29  return {c1, c2};
30 }
31 
32 [[nodiscard]] static inline std::pair<unsigned, unsigned> calcSpil(unsigned c1, unsigned c2, unsigned x)
33 {
34  unsigned r = (c2 * x) >> 8;
35  unsigned s = (c1 * x) >> 8;
36  if (r > 255) {
37  s += (r - 255) / 2;
38  r = 255;
39  }
40  return {r, s};
41 }
42 
43 template<typename Pixel>
44 void RGBTriplet3xScaler<Pixel>::rgbify(
45  const Pixel* __restrict in, Pixel* __restrict out, unsigned inwidth,
46  unsigned c1, unsigned c2)
47 {
48  unsigned i = 0;
49 
50  auto [r, rs] = calcSpil(c1, c2, pixelOps.red256 (in[i + 0]));
51  auto [g, gs] = calcSpil(c1, c2, pixelOps.green256(in[i + 0]));
52  out[3 * i + 0] = pixelOps.combine256(r , gs, 0 );
53  auto [b, bs] = calcSpil(c1, c2, pixelOps.blue256 (in[i + 0]));
54  out[3 * i + 1] = pixelOps.combine256(rs, g , bs);
55  std::tie(r, rs) = calcSpil(c1, c2, pixelOps.red256 (in[i + 1]));
56  out[3 * i + 2] = pixelOps.combine256(rs, gs, b );
57 
58  for (++i; i < (inwidth - 1); ++i) {
59  std::tie(g, gs) = calcSpil(c1, c2, pixelOps.green256(in[i + 0]));
60  out[3 * i + 0] = pixelOps.combine256(r , gs, bs);
61  std::tie(b, bs) = calcSpil(c1, c2, pixelOps.blue256 (in[i + 0]));
62  out[3 * i + 1] = pixelOps.combine256(rs, g , bs);
63  std::tie(r, rs) = calcSpil(c1, c2, pixelOps.red256 (in[i + 1]));
64  out[3 * i + 2] = pixelOps.combine256(rs, gs, b );
65  }
66 
67  std::tie(g, gs) = calcSpil(c1, c2, pixelOps.green256(in[i + 0]));
68  out[3 * i + 0] = pixelOps.combine256(r , gs, bs);
69  std::tie(b, bs) = calcSpil(c1, c2, pixelOps.blue256 (in[i + 0]));
70  out[3 * i + 1] = pixelOps.combine256(rs, g , bs);
71  out[3 * i + 2] = pixelOps.combine256(0 , gs, b );
72 }
73 
74 template<typename Pixel>
75 void RGBTriplet3xScaler<Pixel>::scaleLine(
76  const Pixel* srcLine, Pixel* dstLine, PolyLineScaler<Pixel>& scale,
77  unsigned tmpWidth, unsigned c1, unsigned c2)
78 {
79  if (scale.isCopy()) {
80  rgbify(srcLine, dstLine, tmpWidth, c1, c2);
81  } else {
82  VLA_SSE_ALIGNED(Pixel, tmp, tmpWidth);
83  scale(srcLine, tmp, tmpWidth);
84  rgbify(tmp, dstLine, tmpWidth, c1, c2);
85  }
86 }
87 
88 // Note: the idea is that this method RGBifies a line that is first scaled
89 // to output-width / 3. So, when calling this, keep this in mind and pass a
90 // scale functor that scales the input with correctly.
91 template<typename Pixel>
92 void RGBTriplet3xScaler<Pixel>::doScale1(FrameSource& src,
93  unsigned srcStartY, unsigned /*srcEndY*/, unsigned srcWidth,
94  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY,
95  PolyLineScaler<Pixel>& scale)
96 {
97  VLA_SSE_ALIGNED(Pixel, buf, srcWidth);
98 
99  auto [c1, c2] = calcBlur();
100 
101  unsigned dstWidth = dst.getWidth();
102  unsigned tmpWidth = dstWidth / 3;
103  int scanlineFactor = settings.getScanlineFactor();
104  unsigned y = dstStartY;
105  auto* srcLine = src.getLinePtr(srcStartY++, srcWidth, buf);
106  auto* dstLine0 = dst.acquireLine(y + 0);
107  scaleLine(srcLine, dstLine0, scale, tmpWidth, c1, c2);
108 
109  Scale_1on1<Pixel> copy;
110  auto* dstLine1 = dst.acquireLine(y + 1);
111  copy(dstLine0, dstLine1, dstWidth);
112 
113  for (/* */; (y + 4) < dstEndY; y += 3, srcStartY += 1) {
114  srcLine = src.getLinePtr(srcStartY, srcWidth, buf);
115  auto* dstLine3 = dst.acquireLine(y + 3);
116  scaleLine(srcLine, dstLine3, scale, tmpWidth, c1, c2);
117 
118  auto* dstLine4 = dst.acquireLine(y + 4);
119  copy(dstLine3, dstLine4, dstWidth);
120 
121  auto* dstLine2 = dst.acquireLine(y + 2);
122  scanline.draw(dstLine0, dstLine3, dstLine2,
123  scanlineFactor, dstWidth);
124 
125  dst.releaseLine(y + 0, dstLine0);
126  dst.releaseLine(y + 1, dstLine1);
127  dst.releaseLine(y + 2, dstLine2);
128  dstLine0 = dstLine3;
129  dstLine1 = dstLine4;
130  }
131 
132  srcLine = src.getLinePtr(srcStartY, srcWidth, buf);
133  VLA_SSE_ALIGNED(Pixel, buf2, dstWidth);
134  scaleLine(srcLine, buf2, scale, tmpWidth, c1, c2);
135  auto* dstLine2 = dst.acquireLine(y + 2);
136  scanline.draw(dstLine0, buf2, dstLine2, scanlineFactor, dstWidth);
137  dst.releaseLine(y + 0, dstLine0);
138  dst.releaseLine(y + 1, dstLine1);
139  dst.releaseLine(y + 2, dstLine2);
140 }
141 
142 template<typename Pixel>
143 void RGBTriplet3xScaler<Pixel>::doScale2(FrameSource& src,
144  unsigned srcStartY, unsigned /*srcEndY*/, unsigned srcWidth,
145  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY,
146  PolyLineScaler<Pixel>& scale)
147 {
148  VLA_SSE_ALIGNED(Pixel, buf, srcWidth);
149  auto [c1, c2] = calcBlur();
150 
151  unsigned dstWidth = dst.getWidth();
152  unsigned tmpWidth = dstWidth / 3;
153  int scanlineFactor = settings.getScanlineFactor();
154  for (unsigned srcY = srcStartY, dstY = dstStartY; dstY < dstEndY;
155  srcY += 2, dstY += 3) {
156  auto* srcLine0 = src.getLinePtr(srcY + 0, srcWidth, buf);
157  auto* dstLine0 = dst.acquireLine(dstY + 0);
158  scaleLine(srcLine0, dstLine0, scale, tmpWidth, c1, c2);
159 
160  auto* srcLine1 = src.getLinePtr(srcY + 1, srcWidth, buf);
161  auto* dstLine2 = dst.acquireLine(dstY + 2);
162  scaleLine(srcLine1, dstLine2, scale, tmpWidth, c1, c2);
163 
164  auto* dstLine1 = dst.acquireLine(dstY + 1);
165  scanline.draw(dstLine0, dstLine2, dstLine1,
166  scanlineFactor, dstWidth);
167 
168  dst.releaseLine(dstY + 0, dstLine0);
169  dst.releaseLine(dstY + 1, dstLine1);
170  dst.releaseLine(dstY + 2, dstLine2);
171  }
172 }
173 
174 template<typename Pixel>
176  unsigned srcStartY, unsigned srcEndY, unsigned srcWidth,
177  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
178 {
180  doScale1(src, srcStartY, srcEndY, srcWidth,
181  dst, dstStartY, dstEndY, op);
182 }
183 
184 template<typename Pixel>
186  unsigned srcStartY, unsigned srcEndY, unsigned srcWidth,
187  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
188 {
190  doScale2(src, srcStartY, srcEndY, srcWidth,
191  dst, dstStartY, dstEndY, op);
192 }
193 
194 template<typename Pixel>
196  unsigned srcStartY, unsigned srcEndY, unsigned srcWidth,
197  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
198 {
200  doScale1(src, srcStartY, srcEndY, srcWidth,
201  dst, dstStartY, dstEndY, op);
202 }
203 
204 template<typename Pixel>
206  unsigned srcStartY, unsigned srcEndY, unsigned srcWidth,
207  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
208 {
210  doScale2(src, srcStartY, srcEndY, srcWidth,
211  dst, dstStartY, dstEndY, op);
212 }
213 
214 template<typename Pixel>
216  unsigned srcStartY, unsigned srcEndY, unsigned srcWidth,
217  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
218 {
220  doScale1(src, srcStartY, srcEndY, srcWidth,
221  dst, dstStartY, dstEndY, op);
222 }
223 
224 template<typename Pixel>
226  unsigned srcStartY, unsigned srcEndY, unsigned srcWidth,
227  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
228 {
230  doScale2(src, srcStartY, srcEndY, srcWidth,
231  dst, dstStartY, dstEndY, op);
232 }
233 
234 template<typename Pixel>
236  unsigned srcStartY, unsigned srcEndY, unsigned srcWidth,
237  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
238 {
240  doScale1(src, srcStartY, srcEndY, srcWidth,
241  dst, dstStartY, dstEndY, op);
242 }
243 
244 template<typename Pixel>
246  unsigned srcStartY, unsigned srcEndY, unsigned srcWidth,
247  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
248 {
250  doScale2(src, srcStartY, srcEndY, srcWidth,
251  dst, dstStartY, dstEndY, op);
252 }
253 
254 template<typename Pixel>
256  unsigned srcStartY, unsigned srcEndY, unsigned srcWidth,
257  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
258 {
260  doScale1(src, srcStartY, srcEndY, srcWidth,
261  dst, dstStartY, dstEndY, op);
262 }
263 
264 template<typename Pixel>
266  unsigned srcStartY, unsigned srcEndY, unsigned srcWidth,
267  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
268 {
270  doScale2(src, srcStartY, srcEndY, srcWidth,
271  dst, dstStartY, dstEndY, op);
272 }
273 
274 template<typename Pixel>
276  unsigned srcStartY, unsigned srcEndY, unsigned srcWidth,
277  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
278 {
280  doScale1(src, srcStartY, srcEndY, srcWidth,
281  dst, dstStartY, dstEndY, op);
282 }
283 
284 template<typename Pixel>
286  unsigned srcStartY, unsigned srcEndY, unsigned srcWidth,
287  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
288 {
290  doScale2(src, srcStartY, srcEndY, srcWidth,
291  dst, dstStartY, dstEndY, op);
292 }
293 
294 template<typename Pixel>
295 static void fillLoop(const Pixel* __restrict in, Pixel* __restrict out,
296  unsigned dstWidth)
297 {
298  out[0] = in[0];
299  out[1] = in[1];
300  out[2] = in[2];
301  for (unsigned x = 3; x < (dstWidth - 3); x += 3) {
302  out[x + 0] = in[3];
303  out[x + 1] = in[4];
304  out[x + 2] = in[5];
305  }
306  out[dstWidth - 3] = in[6];
307  out[dstWidth - 2] = in[7];
308  out[dstWidth - 1] = in[8];
309 }
310 
311 template<typename Pixel>
313  FrameSource& src, unsigned srcStartY, unsigned srcEndY,
314  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
315 {
316  auto [c1, c2] = calcBlur();
317  int scanlineFactor = settings.getScanlineFactor();
318 
319  unsigned dstWidth = dst.getWidth();
320  unsigned dstHeight = dst.getHeight();
321  unsigned stopDstY = (dstEndY == dstHeight)
322  ? dstEndY : dstEndY - 3;
323  unsigned srcY = srcStartY, dstY = dstStartY;
324  for (/* */; dstY < stopDstY; srcY += 1, dstY += 3) {
325  auto color = src.getLineColor<Pixel>(srcY);
326 
327  Pixel inNormal [3];
328  Pixel outNormal[3 * 3];
329  inNormal[0] = inNormal[1] = inNormal[2] = color;
330  rgbify(inNormal, outNormal, 3, c1, c2);
331  Pixel outScanline[3 * 3];
332  for (int i = 0; i < (3 * 3); ++i) {
333  outScanline[i] = scanline.darken(
334  outNormal[i], scanlineFactor);
335  }
336 
337  auto* dstLine0 = dst.acquireLine(dstY + 0);
338  fillLoop(outNormal, dstLine0, dstWidth);
339  dst.releaseLine(dstY + 0, dstLine0);
340 
341  auto* dstLine1 = dst.acquireLine(dstY + 1);
342  fillLoop(outNormal, dstLine1, dstWidth);
343  dst.releaseLine(dstY + 1, dstLine1);
344 
345  auto* dstLine2 = dst.acquireLine(dstY + 2);
346  fillLoop(outScanline, dstLine2, dstWidth);
347  dst.releaseLine(dstY + 2, dstLine2);
348  }
349  if (dstY != dstHeight) {
350  unsigned nextLineWidth = src.getLineWidth(srcY + 1);
351  assert(src.getLineWidth(srcY) == 1);
352  assert(nextLineWidth != 1);
353  this->dispatchScale(src, srcY, srcEndY, nextLineWidth,
354  dst, dstY, dstEndY);
355  }
356 }
357 
358 template<typename Pixel>
360  FrameSource& src, unsigned srcStartY, unsigned /*srcEndY*/,
361  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
362 {
363  auto [c1, c2] = calcBlur();
364  int scanlineFactor = settings.getScanlineFactor();
365  unsigned dstWidth = dst.getWidth();
366  for (unsigned srcY = srcStartY, dstY = dstStartY;
367  dstY < dstEndY; srcY += 2, dstY += 3) {
368  auto color0 = src.getLineColor<Pixel>(srcY + 0);
369  auto color1 = src.getLineColor<Pixel>(srcY + 1);
370 
371  Pixel inNormal [3];
372  Pixel out0Normal[3 * 3];
373  Pixel out1Normal[3 * 3];
374  Pixel outScanline[3 * 3];
375 
376  inNormal[0] = inNormal[1] = inNormal[2] = color0;
377  rgbify(inNormal, out0Normal, 3, c1, c2);
378  inNormal[0] = inNormal[1] = inNormal[2] = color1;
379  rgbify(inNormal, out1Normal, 3, c1, c2);
380 
381  for (int i = 0; i < (3 * 3); ++i) {
382  outScanline[i] = scanline.darken(
383  out0Normal[i], out1Normal[i],
384  scanlineFactor);
385  }
386 
387  auto* dstLine0 = dst.acquireLine(dstY + 0);
388  fillLoop(out0Normal, dstLine0, dstWidth);
389  dst.releaseLine(dstY + 0, dstLine0);
390 
391  auto* dstLine1 = dst.acquireLine(dstY + 1);
392  fillLoop(outScanline, dstLine1, dstWidth);
393  dst.releaseLine(dstY + 1, dstLine1);
394 
395  auto* dstLine2 = dst.acquireLine(dstY + 2);
396  fillLoop(out1Normal, dstLine2, dstWidth);
397  dst.releaseLine(dstY + 2, dstLine2);
398  }
399 }
400 
401 template<typename Pixel>
403  unsigned srcStartY, unsigned srcEndY, unsigned srcWidth,
404  ScalerOutput<Pixel>& dst, unsigned dstStartY, unsigned dstEndY)
405 {
406  if (superImpose) {
407  SuperImposedVideoFrame<Pixel> sf(src, *superImpose, pixelOps);
408  srcWidth = sf.getLineWidth(srcStartY);
409  this->dispatchScale(sf, srcStartY, srcEndY, srcWidth,
410  dst, dstStartY, dstEndY);
411  } else {
412  this->dispatchScale(src, srcStartY, srcEndY, srcWidth,
413  dst, dstStartY, dstEndY);
414  }
415 }
416 
417 // Force template instantiation.
418 #if HAVE_16BPP
419 template class RGBTriplet3xScaler<uint16_t>;
420 #endif
421 #if HAVE_32BPP
422 template class RGBTriplet3xScaler<uint32_t>;
423 #endif
424 
425 } // namespace openmsx
openmsx::SuperImposedVideoFrame::getLineWidth
unsigned getLineWidth(unsigned line) const override
Gets the number of display pixels on the given line.
Definition: SuperImposedVideoFrame.cc:21
openmsx::RGBTriplet3xScaler::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: RGBTriplet3xScaler.cc:402
openmsx::RGBTriplet3xScaler::scale4x2to3x3
void scale4x2to3x3(FrameSource &src, unsigned srcStartY, unsigned srcEndY, unsigned srcWidth, ScalerOutput< Pixel > &dst, unsigned dstStartY, unsigned dstEndY) override
Definition: RGBTriplet3xScaler.cc:285
openmsx::PixelOperations
Definition: PixelOperations.hh:144
openmsx::RenderSettings
Class containing all settings for renderers.
Definition: RenderSettings.hh:22
openmsx::FrameSource::getLineWidth
virtual unsigned getLineWidth(unsigned line) const =0
Gets the number of display pixels on the given line.
openmsx::RGBTriplet3xScaler::scale2x1to9x3
void scale2x1to9x3(FrameSource &src, unsigned srcStartY, unsigned srcEndY, unsigned srcWidth, ScalerOutput< Pixel > &dst, unsigned dstStartY, unsigned dstEndY) override
Definition: RGBTriplet3xScaler.cc:175
openmsx::ScalerOutput::releaseLine
virtual void releaseLine(unsigned y, Pixel *buf)=0
RGBTriplet3xScaler.hh
RawFrame.hh
openmsx::ScalerOutput::getWidth
virtual unsigned getWidth() const =0
SuperImposedVideoFrame.hh
openmsx::RGBTriplet3xScaler::scale1x2to3x3
void scale1x2to3x3(FrameSource &src, unsigned srcStartY, unsigned srcEndY, unsigned srcWidth, ScalerOutput< Pixel > &dst, unsigned dstStartY, unsigned dstEndY) override
Definition: RGBTriplet3xScaler.cc:205
openmsx::ScalerOutput::getHeight
virtual unsigned getHeight() const =0
openmsx::RGBTriplet3xScaler::scale4x1to3x3
void scale4x1to3x3(FrameSource &src, unsigned srcStartY, unsigned srcEndY, unsigned srcWidth, ScalerOutput< Pixel > &dst, unsigned dstStartY, unsigned dstEndY) override
Definition: RGBTriplet3xScaler.cc:275
openmsx::RGBTriplet3xScaler::scale8x2to9x3
void scale8x2to9x3(FrameSource &src, unsigned srcStartY, unsigned srcEndY, unsigned srcWidth, ScalerOutput< Pixel > &dst, unsigned dstStartY, unsigned dstEndY) override
Definition: RGBTriplet3xScaler.cc:265
openmsx::ScalerOutput
Definition: ScalerOutput.hh:7
vla.hh
openmsx::Pixel
uint32_t Pixel
Definition: GLHQLiteScaler.cc:98
ScalerOutput.hh
openmsx::RGBTriplet3xScaler::scaleBlank1to3
void scaleBlank1to3(FrameSource &src, unsigned srcStartY, unsigned srcEndY, ScalerOutput< Pixel > &dst, unsigned dstStartY, unsigned dstEndY) override
Definition: RGBTriplet3xScaler.cc:312
openmsx::FrameSource::getLineColor
Pixel getLineColor(unsigned line) const
Get the (single) color of the given line.
Definition: FrameSource.hh:73
openmsx::RGBTriplet3xScaler::RGBTriplet3xScaler
RGBTriplet3xScaler(const PixelOperations< Pixel > &pixelOps, const RenderSettings &renderSettings)
Definition: RGBTriplet3xScaler.cc:14
openmsx::PolyScale
Polymorphic wrapper around another line scaler.
Definition: LineScalers.hh:312
build-info.hh
openmsx::RGBTriplet3xScaler::scale2x1to3x3
void scale2x1to3x3(FrameSource &src, unsigned srcStartY, unsigned srcEndY, unsigned srcWidth, ScalerOutput< Pixel > &dst, unsigned dstStartY, unsigned dstEndY) override
Definition: RGBTriplet3xScaler.cc:235
openmsx::ScalerOutput::acquireLine
virtual Pixel * acquireLine(unsigned y)=0
ranges::copy
auto copy(InputRange &&range, OutputIter out)
Definition: ranges.hh:149
openmsx::RGBTriplet3xScaler::scale8x1to9x3
void scale8x1to9x3(FrameSource &src, unsigned srcStartY, unsigned srcEndY, unsigned srcWidth, ScalerOutput< Pixel > &dst, unsigned dstStartY, unsigned dstEndY) override
Definition: RGBTriplet3xScaler.cc:255
openmsx::RawFrame
A video frame as output by the VDP scanline conversion unit, before any postprocessing filters are ap...
Definition: RawFrame.hh:26
RenderSettings.hh
g
int g
Definition: ScopedAssign_test.cc:20
LineScalers.hh
openmsx::x
constexpr KeyMatrixPosition x
Keyboard bindings.
Definition: Keyboard.cc:1416
openmsx::RGBTriplet3xScaler::scale4x2to9x3
void scale4x2to9x3(FrameSource &src, unsigned srcStartY, unsigned srcEndY, unsigned srcWidth, ScalerOutput< Pixel > &dst, unsigned dstStartY, unsigned dstEndY) override
Definition: RGBTriplet3xScaler.cc:225
openmsx::RGBTriplet3xScaler::scale1x1to3x3
void scale1x1to3x3(FrameSource &src, unsigned srcStartY, unsigned srcEndY, unsigned srcWidth, ScalerOutput< Pixel > &dst, unsigned dstStartY, unsigned dstEndY) override
Definition: RGBTriplet3xScaler.cc:195
openmsx::RGBTriplet3xScaler
TODO.
Definition: RGBTriplet3xScaler.hh:18
gl::scale
mat4 scale(const vec3 &xyz)
Definition: gl_transform.hh:19
openmsx::RGBTriplet3xScaler::scaleBlank2to3
void scaleBlank2to3(FrameSource &src, unsigned srcStartY, unsigned srcEndY, ScalerOutput< Pixel > &dst, unsigned dstStartY, unsigned dstEndY) override
Definition: RGBTriplet3xScaler.cc:359
openmsx::Scaler3
Base class for 3x scalers.
Definition: Scaler3.hh:12
openmsx::FrameSource
Interface for getting lines from a video frame.
Definition: FrameSource.hh:14
openmsx::RGBTriplet3xScaler::scale4x1to9x3
void scale4x1to9x3(FrameSource &src, unsigned srcStartY, unsigned srcEndY, unsigned srcWidth, ScalerOutput< Pixel > &dst, unsigned dstStartY, unsigned dstEndY) override
Definition: RGBTriplet3xScaler.cc:215
VLA_SSE_ALIGNED
#define VLA_SSE_ALIGNED(TYPE, NAME, LENGTH)
Definition: vla.hh:44
openmsx::RGBTriplet3xScaler::scale2x2to9x3
void scale2x2to9x3(FrameSource &src, unsigned srcStartY, unsigned srcEndY, unsigned srcWidth, ScalerOutput< Pixel > &dst, unsigned dstStartY, unsigned dstEndY) override
Definition: RGBTriplet3xScaler.cc:185
openmsx
This file implemented 3 utility functions:
Definition: Autofire.cc:5
openmsx::RGBTriplet3xScaler::scale2x2to3x3
void scale2x2to3x3(FrameSource &src, unsigned srcStartY, unsigned srcEndY, unsigned srcWidth, ScalerOutput< Pixel > &dst, unsigned dstStartY, unsigned dstEndY) override
Definition: RGBTriplet3xScaler.cc:245
openmsx::SuperImposedVideoFrame
This class represents a frame that is the (per-pixel) alpha-blend of a (laser-disc) video frame and a...
Definition: SuperImposedVideoFrame.hh:21