1 /*
2 * Copyright 2016 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "SkArithmeticImageFilter.h"
9 #include "SkArithmeticModePriv.h"
10 #include "SkCanvas.h"
11 #include "SkNx.h"
12 #include "SkReadBuffer.h"
13 #include "SkSpecialImage.h"
14 #include "SkSpecialSurface.h"
15 #include "SkWriteBuffer.h"
16 #include "SkXfermodeImageFilter.h"
17 #if SK_SUPPORT_GPU
18 #include "GrClip.h"
19 #include "GrContext.h"
20 #include "GrRenderTargetContext.h"
21 #include "GrTextureProxy.h"
22 #include "SkGr.h"
23 #include "effects/GrConstColorProcessor.h"
24 #include "effects/GrTextureDomain.h"
25 #include "glsl/GrGLSLFragmentProcessor.h"
26 #include "glsl/GrGLSLFragmentShaderBuilder.h"
27 #include "glsl/GrGLSLProgramDataManager.h"
28 #include "glsl/GrGLSLUniformHandler.h"
29 #endif
30
31 namespace {
32 class ArithmeticImageFilterImpl : public SkImageFilter {
33 public:
ArithmeticImageFilterImpl(float k1,float k2,float k3,float k4,bool enforcePMColor,sk_sp<SkImageFilter> inputs[2],const CropRect * cropRect)34 ArithmeticImageFilterImpl(float k1, float k2, float k3, float k4, bool enforcePMColor,
35 sk_sp<SkImageFilter> inputs[2], const CropRect* cropRect)
36 : INHERITED(inputs, 2, cropRect), fK{k1, k2, k3, k4}, fEnforcePMColor(enforcePMColor) {}
37
38 SK_TO_STRING_OVERRIDE()
39 SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(ArithmeticImageFilterImpl)
40
41 protected:
42 sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source, const Context&,
43 SkIPoint* offset) const override;
44
45 #if SK_SUPPORT_GPU
46 sk_sp<SkSpecialImage> filterImageGPU(SkSpecialImage* source,
47 sk_sp<SkSpecialImage> background,
48 const SkIPoint& backgroundOffset,
49 sk_sp<SkSpecialImage> foreground,
50 const SkIPoint& foregroundOffset,
51 const SkIRect& bounds,
52 const OutputProperties& outputProperties) const;
53 #endif
54
flatten(SkWriteBuffer & buffer) const55 void flatten(SkWriteBuffer& buffer) const override {
56 this->INHERITED::flatten(buffer);
57 for (int i = 0; i < 4; ++i) {
58 buffer.writeScalar(fK[i]);
59 }
60 buffer.writeBool(fEnforcePMColor);
61 }
62
63 void drawForeground(SkCanvas* canvas, SkSpecialImage*, const SkIRect&) const;
64
65 private:
66 const float fK[4];
67 const bool fEnforcePMColor;
68
69 friend class ::SkArithmeticImageFilter;
70
71 typedef SkImageFilter INHERITED;
72 };
73 }
74
CreateProc(SkReadBuffer & buffer)75 sk_sp<SkFlattenable> ArithmeticImageFilterImpl::CreateProc(SkReadBuffer& buffer) {
76 SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
77 float k[4];
78 for (int i = 0; i < 4; ++i) {
79 k[i] = buffer.readScalar();
80 }
81 const bool enforcePMColor = buffer.readBool();
82 return SkArithmeticImageFilter::Make(k[0], k[1], k[2], k[3], enforcePMColor, common.getInput(0),
83 common.getInput(1), &common.cropRect());
84 }
85
pin(float min,const Sk4f & val,float max)86 static Sk4f pin(float min, const Sk4f& val, float max) {
87 return Sk4f::Max(min, Sk4f::Min(val, max));
88 }
89
90 template <bool EnforcePMColor>
arith_span(const float k[],SkPMColor dst[],const SkPMColor src[],int count)91 void arith_span(const float k[], SkPMColor dst[], const SkPMColor src[], int count) {
92 const Sk4f k1 = k[0] * (1/255.0f),
93 k2 = k[1],
94 k3 = k[2],
95 k4 = k[3] * 255.0f + 0.5f;
96
97 for (int i = 0; i < count; i++) {
98 Sk4f s = SkNx_cast<float>(Sk4b::Load(src+i)),
99 d = SkNx_cast<float>(Sk4b::Load(dst+i)),
100 r = pin(0, k1*s*d + k2*s + k3*d + k4, 255);
101 if (EnforcePMColor) {
102 Sk4f a = SkNx_shuffle<3,3,3,3>(r);
103 r = Sk4f::Min(a, r);
104 }
105 SkNx_cast<uint8_t>(r).store(dst+i);
106 }
107 }
108
109 // apply mode to src==transparent (0)
arith_transparent(const float k[],SkPMColor dst[],int count)110 template<bool EnforcePMColor> void arith_transparent(const float k[], SkPMColor dst[], int count) {
111 const Sk4f k3 = k[2],
112 k4 = k[3] * 255.0f + 0.5f;
113
114 for (int i = 0; i < count; i++) {
115 Sk4f d = SkNx_cast<float>(Sk4b::Load(dst+i)),
116 r = pin(0, k3*d + k4, 255);
117 if (EnforcePMColor) {
118 Sk4f a = SkNx_shuffle<3,3,3,3>(r);
119 r = Sk4f::Min(a, r);
120 }
121 SkNx_cast<uint8_t>(r).store(dst+i);
122 }
123 }
124
intersect(SkPixmap * dst,SkPixmap * src,int srcDx,int srcDy)125 static bool intersect(SkPixmap* dst, SkPixmap* src, int srcDx, int srcDy) {
126 SkIRect dstR = SkIRect::MakeWH(dst->width(), dst->height());
127 SkIRect srcR = SkIRect::MakeXYWH(srcDx, srcDy, src->width(), src->height());
128 SkIRect sect;
129 if (!sect.intersect(dstR, srcR)) {
130 return false;
131 }
132 *dst = SkPixmap(dst->info().makeWH(sect.width(), sect.height()),
133 dst->addr(sect.fLeft, sect.fTop),
134 dst->rowBytes());
135 *src = SkPixmap(src->info().makeWH(sect.width(), sect.height()),
136 src->addr(SkTMax(0, -srcDx), SkTMax(0, -srcDy)),
137 src->rowBytes());
138 return true;
139 }
140
onFilterImage(SkSpecialImage * source,const Context & ctx,SkIPoint * offset) const141 sk_sp<SkSpecialImage> ArithmeticImageFilterImpl::onFilterImage(SkSpecialImage* source,
142 const Context& ctx,
143 SkIPoint* offset) const {
144 SkIPoint backgroundOffset = SkIPoint::Make(0, 0);
145 sk_sp<SkSpecialImage> background(this->filterInput(0, source, ctx, &backgroundOffset));
146
147 SkIPoint foregroundOffset = SkIPoint::Make(0, 0);
148 sk_sp<SkSpecialImage> foreground(this->filterInput(1, source, ctx, &foregroundOffset));
149
150 SkIRect foregroundBounds = SkIRect::EmptyIRect();
151 if (foreground) {
152 foregroundBounds = SkIRect::MakeXYWH(foregroundOffset.x(), foregroundOffset.y(),
153 foreground->width(), foreground->height());
154 }
155
156 SkIRect srcBounds = SkIRect::EmptyIRect();
157 if (background) {
158 srcBounds = SkIRect::MakeXYWH(backgroundOffset.x(), backgroundOffset.y(),
159 background->width(), background->height());
160 }
161
162 srcBounds.join(foregroundBounds);
163 if (srcBounds.isEmpty()) {
164 return nullptr;
165 }
166
167 SkIRect bounds;
168 if (!this->applyCropRect(ctx, srcBounds, &bounds)) {
169 return nullptr;
170 }
171
172 offset->fX = bounds.left();
173 offset->fY = bounds.top();
174
175 #if SK_SUPPORT_GPU
176 if (source->isTextureBacked()) {
177 return this->filterImageGPU(source, background, backgroundOffset, foreground,
178 foregroundOffset, bounds, ctx.outputProperties());
179 }
180 #endif
181
182 sk_sp<SkSpecialSurface> surf(source->makeSurface(ctx.outputProperties(), bounds.size()));
183 if (!surf) {
184 return nullptr;
185 }
186
187 SkCanvas* canvas = surf->getCanvas();
188 SkASSERT(canvas);
189
190 canvas->clear(0x0); // can't count on background to fully clear the background
191 canvas->translate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
192
193 if (background) {
194 SkPaint paint;
195 paint.setBlendMode(SkBlendMode::kSrc);
196 background->draw(canvas, SkIntToScalar(backgroundOffset.fX),
197 SkIntToScalar(backgroundOffset.fY), &paint);
198 }
199
200 this->drawForeground(canvas, foreground.get(), foregroundBounds);
201
202 return surf->makeImageSnapshot();
203 }
204
205 #if SK_SUPPORT_GPU
206
207 namespace {
208 class ArithmeticFP : public GrFragmentProcessor {
209 public:
Make(float k1,float k2,float k3,float k4,bool enforcePMColor,sk_sp<GrFragmentProcessor> dst)210 static sk_sp<GrFragmentProcessor> Make(float k1, float k2, float k3, float k4,
211 bool enforcePMColor, sk_sp<GrFragmentProcessor> dst) {
212 return sk_sp<GrFragmentProcessor>(
213 new ArithmeticFP(k1, k2, k3, k4, enforcePMColor, std::move(dst)));
214 }
215
~ArithmeticFP()216 ~ArithmeticFP() override {}
217
name() const218 const char* name() const override { return "Arithmetic"; }
219
dumpInfo() const220 SkString dumpInfo() const override {
221 SkString str;
222 str.appendf("K1: %.2f K2: %.2f K3: %.2f K4: %.2f", fK1, fK2, fK3, fK4);
223 return str;
224 }
225
k1() const226 float k1() const { return fK1; }
k2() const227 float k2() const { return fK2; }
k3() const228 float k3() const { return fK3; }
k4() const229 float k4() const { return fK4; }
enforcePMColor() const230 bool enforcePMColor() const { return fEnforcePMColor; }
231
232 private:
onCreateGLSLInstance() const233 GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
234 class GLSLFP : public GrGLSLFragmentProcessor {
235 public:
236 void emitCode(EmitArgs& args) override {
237 const ArithmeticFP& arith = args.fFp.cast<ArithmeticFP>();
238
239 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
240 SkString dstColor("dstColor");
241 this->emitChild(0, nullptr, &dstColor, args);
242
243 fKUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kVec4f_GrSLType,
244 kDefault_GrSLPrecision, "k");
245 const char* kUni = args.fUniformHandler->getUniformCStr(fKUni);
246
247 // We don't try to optimize for this case at all
248 if (!args.fInputColor) {
249 fragBuilder->codeAppend("const vec4 src = vec4(1);");
250 } else {
251 fragBuilder->codeAppendf("vec4 src = %s;", args.fInputColor);
252 }
253
254 fragBuilder->codeAppendf("vec4 dst = %s;", dstColor.c_str());
255 fragBuilder->codeAppendf("%s = %s.x * src * dst + %s.y * src + %s.z * dst + %s.w;",
256 args.fOutputColor, kUni, kUni, kUni, kUni);
257 fragBuilder->codeAppendf("%s = clamp(%s, 0.0, 1.0);\n", args.fOutputColor,
258 args.fOutputColor);
259 if (arith.fEnforcePMColor) {
260 fragBuilder->codeAppendf("%s.rgb = min(%s.rgb, %s.a);", args.fOutputColor,
261 args.fOutputColor, args.fOutputColor);
262 }
263 }
264
265 protected:
266 void onSetData(const GrGLSLProgramDataManager& pdman,
267 const GrProcessor& proc) override {
268 const ArithmeticFP& arith = proc.cast<ArithmeticFP>();
269 pdman.set4f(fKUni, arith.k1(), arith.k2(), arith.k3(), arith.k4());
270 }
271
272 private:
273 GrGLSLProgramDataManager::UniformHandle fKUni;
274 };
275 return new GLSLFP;
276 }
277
onGetGLSLProcessorKey(const GrShaderCaps & caps,GrProcessorKeyBuilder * b) const278 void onGetGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override {
279 b->add32(fEnforcePMColor ? 1 : 0);
280 }
281
onIsEqual(const GrFragmentProcessor & fpBase) const282 bool onIsEqual(const GrFragmentProcessor& fpBase) const override {
283 const ArithmeticFP& fp = fpBase.cast<ArithmeticFP>();
284 return fK1 == fp.fK1 && fK2 == fp.fK2 && fK3 == fp.fK3 && fK4 == fp.fK4 &&
285 fEnforcePMColor == fp.fEnforcePMColor;
286 }
287
288 // This could implement the const input -> const output optimization but it's unlikely to help.
ArithmeticFP(float k1,float k2,float k3,float k4,bool enforcePMColor,sk_sp<GrFragmentProcessor> dst)289 ArithmeticFP(float k1, float k2, float k3, float k4, bool enforcePMColor,
290 sk_sp<GrFragmentProcessor> dst)
291 : INHERITED(kNone_OptimizationFlags)
292 , fK1(k1)
293 , fK2(k2)
294 , fK3(k3)
295 , fK4(k4)
296 , fEnforcePMColor(enforcePMColor) {
297 this->initClassID<ArithmeticFP>();
298 SkASSERT(dst);
299 SkDEBUGCODE(int dstIndex =) this->registerChildProcessor(std::move(dst));
300 SkASSERT(0 == dstIndex);
301 }
302
303 float fK1, fK2, fK3, fK4;
304 bool fEnforcePMColor;
305
306 GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
307 typedef GrFragmentProcessor INHERITED;
308 };
309 }
310
311 #if GR_TEST_UTILS
TestCreate(GrProcessorTestData * d)312 sk_sp<GrFragmentProcessor> ArithmeticFP::TestCreate(GrProcessorTestData* d) {
313 float k1 = d->fRandom->nextF();
314 float k2 = d->fRandom->nextF();
315 float k3 = d->fRandom->nextF();
316 float k4 = d->fRandom->nextF();
317 bool enforcePMColor = d->fRandom->nextBool();
318
319 sk_sp<GrFragmentProcessor> dst(GrProcessorUnitTest::MakeChildFP(d));
320 return ArithmeticFP::Make(k1, k2, k3, k4, enforcePMColor, std::move(dst));
321 }
322 #endif
323
324 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ArithmeticFP);
325
filterImageGPU(SkSpecialImage * source,sk_sp<SkSpecialImage> background,const SkIPoint & backgroundOffset,sk_sp<SkSpecialImage> foreground,const SkIPoint & foregroundOffset,const SkIRect & bounds,const OutputProperties & outputProperties) const326 sk_sp<SkSpecialImage> ArithmeticImageFilterImpl::filterImageGPU(
327 SkSpecialImage* source,
328 sk_sp<SkSpecialImage>
329 background,
330 const SkIPoint& backgroundOffset,
331 sk_sp<SkSpecialImage>
332 foreground,
333 const SkIPoint& foregroundOffset,
334 const SkIRect& bounds,
335 const OutputProperties& outputProperties) const {
336 SkASSERT(source->isTextureBacked());
337
338 GrContext* context = source->getContext();
339
340 sk_sp<GrTextureProxy> backgroundProxy, foregroundProxy;
341
342 if (background) {
343 backgroundProxy = background->asTextureProxyRef(context);
344 }
345
346 if (foreground) {
347 foregroundProxy = foreground->asTextureProxyRef(context);
348 }
349
350 GrPaint paint;
351 sk_sp<GrFragmentProcessor> bgFP;
352
353 if (backgroundProxy) {
354 SkMatrix backgroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(backgroundOffset.fX),
355 -SkIntToScalar(backgroundOffset.fY));
356 sk_sp<GrColorSpaceXform> bgXform =
357 GrColorSpaceXform::Make(background->getColorSpace(), outputProperties.colorSpace());
358 bgFP = GrTextureDomainEffect::Make(
359 context->resourceProvider(), std::move(backgroundProxy), std::move(bgXform),
360 backgroundMatrix, GrTextureDomain::MakeTexelDomain(background->subset()),
361 GrTextureDomain::kDecal_Mode, GrSamplerParams::kNone_FilterMode);
362 } else {
363 bgFP = GrConstColorProcessor::Make(GrColor4f::TransparentBlack(),
364 GrConstColorProcessor::kIgnore_InputMode);
365 }
366
367 if (foregroundProxy) {
368 SkMatrix foregroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(foregroundOffset.fX),
369 -SkIntToScalar(foregroundOffset.fY));
370 sk_sp<GrColorSpaceXform> fgXform =
371 GrColorSpaceXform::Make(foreground->getColorSpace(), outputProperties.colorSpace());
372 sk_sp<GrFragmentProcessor> foregroundFP;
373
374 foregroundFP = GrTextureDomainEffect::Make(
375 context->resourceProvider(), std::move(foregroundProxy), std::move(fgXform),
376 foregroundMatrix, GrTextureDomain::MakeTexelDomain(foreground->subset()),
377 GrTextureDomain::kDecal_Mode, GrSamplerParams::kNone_FilterMode);
378
379 paint.addColorFragmentProcessor(std::move(foregroundFP));
380
381 sk_sp<GrFragmentProcessor> xferFP =
382 ArithmeticFP::Make(fK[0], fK[1], fK[2], fK[3], fEnforcePMColor, std::move(bgFP));
383
384 // A null 'xferFP' here means kSrc_Mode was used in which case we can just proceed
385 if (xferFP) {
386 paint.addColorFragmentProcessor(std::move(xferFP));
387 }
388 } else {
389 paint.addColorFragmentProcessor(std::move(bgFP));
390 }
391
392 paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
393
394 sk_sp<GrRenderTargetContext> renderTargetContext(context->makeDeferredRenderTargetContext(
395 SkBackingFit::kApprox, bounds.width(), bounds.height(),
396 GrRenderableConfigForColorSpace(outputProperties.colorSpace()),
397 sk_ref_sp(outputProperties.colorSpace())));
398 if (!renderTargetContext) {
399 return nullptr;
400 }
401 paint.setGammaCorrect(renderTargetContext->isGammaCorrect());
402
403 SkMatrix matrix;
404 matrix.setTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
405 renderTargetContext->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, matrix,
406 SkRect::Make(bounds));
407
408 return SkSpecialImage::MakeDeferredFromGpu(context,
409 SkIRect::MakeWH(bounds.width(), bounds.height()),
410 kNeedNewImageUniqueID_SpecialImage,
411 renderTargetContext->asTextureProxyRef(),
412 renderTargetContext->refColorSpace());
413 }
414 #endif
415
drawForeground(SkCanvas * canvas,SkSpecialImage * img,const SkIRect & fgBounds) const416 void ArithmeticImageFilterImpl::drawForeground(SkCanvas* canvas, SkSpecialImage* img,
417 const SkIRect& fgBounds) const {
418 SkPixmap dst;
419 if (!canvas->peekPixels(&dst)) {
420 return;
421 }
422
423 const SkMatrix& ctm = canvas->getTotalMatrix();
424 SkASSERT(ctm.getType() <= SkMatrix::kTranslate_Mask);
425 const int dx = SkScalarRoundToInt(ctm.getTranslateX());
426 const int dy = SkScalarRoundToInt(ctm.getTranslateY());
427
428 if (img) {
429 SkBitmap srcBM;
430 SkPixmap src;
431 if (!img->getROPixels(&srcBM)) {
432 return;
433 }
434 srcBM.lockPixels();
435 if (!srcBM.peekPixels(&src)) {
436 return;
437 }
438
439 auto proc = fEnforcePMColor ? arith_span<true> : arith_span<false>;
440 SkPixmap tmpDst = dst;
441 if (intersect(&tmpDst, &src, fgBounds.fLeft + dx, fgBounds.fTop + dy)) {
442 for (int y = 0; y < tmpDst.height(); ++y) {
443 proc(fK, tmpDst.writable_addr32(0, y), src.addr32(0, y), tmpDst.width());
444 }
445 }
446 }
447
448 // Now apply the mode with transparent-color to the outside of the fg image
449 SkRegion outside(SkIRect::MakeWH(dst.width(), dst.height()));
450 outside.op(fgBounds.makeOffset(dx, dy), SkRegion::kDifference_Op);
451 auto proc = fEnforcePMColor ? arith_transparent<true> : arith_transparent<false>;
452 for (SkRegion::Iterator iter(outside); !iter.done(); iter.next()) {
453 const SkIRect r = iter.rect();
454 for (int y = r.fTop; y < r.fBottom; ++y) {
455 proc(fK, dst.writable_addr32(r.fLeft, y), r.width());
456 }
457 }
458 }
459
460 #ifndef SK_IGNORE_TO_STRING
toString(SkString * str) const461 void ArithmeticImageFilterImpl::toString(SkString* str) const {
462 str->appendf("SkArithmeticImageFilter: (");
463 str->appendf("K[]: (%f %f %f %f)", fK[0], fK[1], fK[2], fK[3]);
464 if (this->getInput(0)) {
465 str->appendf("foreground: (");
466 this->getInput(0)->toString(str);
467 str->appendf(")");
468 }
469 if (this->getInput(1)) {
470 str->appendf("background: (");
471 this->getInput(1)->toString(str);
472 str->appendf(")");
473 }
474 str->append(")");
475 }
476 #endif
477
Make(float k1,float k2,float k3,float k4,bool enforcePMColor,sk_sp<SkImageFilter> background,sk_sp<SkImageFilter> foreground,const SkImageFilter::CropRect * crop)478 sk_sp<SkImageFilter> SkArithmeticImageFilter::Make(float k1, float k2, float k3, float k4,
479 bool enforcePMColor,
480 sk_sp<SkImageFilter> background,
481 sk_sp<SkImageFilter> foreground,
482 const SkImageFilter::CropRect* crop) {
483 if (!SkScalarIsFinite(k1) || !SkScalarIsFinite(k2) || !SkScalarIsFinite(k3) ||
484 !SkScalarIsFinite(k4)) {
485 return nullptr;
486 }
487
488 // are we nearly some other "std" mode?
489 int mode = -1; // illegal mode
490 if (SkScalarNearlyZero(k1) && SkScalarNearlyEqual(k2, SK_Scalar1) && SkScalarNearlyZero(k3) &&
491 SkScalarNearlyZero(k4)) {
492 mode = (int)SkBlendMode::kSrc;
493 } else if (SkScalarNearlyZero(k1) && SkScalarNearlyZero(k2) &&
494 SkScalarNearlyEqual(k3, SK_Scalar1) && SkScalarNearlyZero(k4)) {
495 mode = (int)SkBlendMode::kDst;
496 } else if (SkScalarNearlyZero(k1) && SkScalarNearlyZero(k2) && SkScalarNearlyZero(k3) &&
497 SkScalarNearlyZero(k4)) {
498 mode = (int)SkBlendMode::kClear;
499 }
500 if (mode >= 0) {
501 return SkXfermodeImageFilter::Make((SkBlendMode)mode, std::move(background),
502 std::move(foreground), crop);
503 }
504
505 sk_sp<SkImageFilter> inputs[2] = {std::move(background), std::move(foreground)};
506 return sk_sp<SkImageFilter>(
507 new ArithmeticImageFilterImpl(k1, k2, k3, k4, enforcePMColor, inputs, crop));
508 }
509
510 ///////////////////////////////////////////////////////////////////////////////////////////////////
511
512 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkArithmeticImageFilter)
513 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(ArithmeticImageFilterImpl)
514 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
515