blob: 8e38ae716d1d69f71a6defdc568e6b68b682e461 [file] [log] [blame]
mike@reedtribe.org70e35902012-07-29 20:38:16 +00001/*
2 * Copyright 2011 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
bsalomon8e74f802016-01-30 10:01:40 -08008#include <functional>
mike@reedtribe.org70e35902012-07-29 20:38:16 +00009#include "gm.h"
Mike Klein33d20552017-03-22 13:47:51 -040010#include "sk_tool_utils.h"
robertphillipsc5035e72016-03-17 06:58:39 -070011#include "SkAutoPixmapStorage.h"
mike@reedtribe.orgd829b5c2012-07-31 03:57:11 +000012#include "SkData.h"
reedf803da12015-01-23 05:58:07 -080013#include "SkCanvas.h"
14#include "SkRandom.h"
15#include "SkStream.h"
16#include "SkSurface.h"
mike@reedtribe.orgd829b5c2012-07-31 03:57:11 +000017
robertphillips@google.com97b6b072012-10-31 14:48:39 +000018#if SK_SUPPORT_GPU
19#include "GrContext.h"
robertphillips@google.com97b6b072012-10-31 14:48:39 +000020#endif
reed@google.com97af1a62012-08-28 12:19:02 +000021
mike@reedtribe.orgd829b5c2012-07-31 03:57:11 +000022static void drawJpeg(SkCanvas* canvas, const SkISize& size) {
scroggo@google.comccd7afb2013-05-28 16:45:07 +000023 // TODO: Make this draw a file that is checked in, so it can
24 // be exercised on machines other than mike's. Will require a
25 // rebaseline.
reed9ce9d672016-03-17 10:51:11 -070026 sk_sp<SkData> data(SkData::MakeFromFileName("/Users/mike/Downloads/skia.google.jpeg"));
27 if (nullptr == data) {
reed48925e32014-09-18 13:57:05 -070028 return;
29 }
reed9ce9d672016-03-17 10:51:11 -070030 sk_sp<SkImage> image = SkImage::MakeFromEncoded(std::move(data));
mike@reedtribe.orgd829b5c2012-07-31 03:57:11 +000031 if (image) {
32 SkAutoCanvasRestore acr(canvas, true);
33 canvas->scale(size.width() * 1.0f / image->width(),
34 size.height() * 1.0f / image->height());
halcanary96fcdcc2015-08-27 07:41:13 -070035 canvas->drawImage(image, 0, 0, nullptr);
mike@reedtribe.orgd829b5c2012-07-31 03:57:11 +000036 }
37}
mike@reedtribe.org70e35902012-07-29 20:38:16 +000038
39static void drawContents(SkSurface* surface, SkColor fillC) {
skia.committer@gmail.com04ba4482012-09-07 02:01:30 +000040 SkSize size = SkSize::Make(SkIntToScalar(surface->width()),
robertphillips@google.com94acc702012-09-06 18:43:21 +000041 SkIntToScalar(surface->height()));
mike@reedtribe.orgd2782ed2012-07-31 02:45:15 +000042 SkCanvas* canvas = surface->getCanvas();
mike@reedtribe.org70e35902012-07-29 20:38:16 +000043
44 SkScalar stroke = size.fWidth / 10;
45 SkScalar radius = (size.fWidth - stroke) / 2;
46
47 SkPaint paint;
rmistry@google.comae933ce2012-08-23 18:19:56 +000048
mike@reedtribe.org70e35902012-07-29 20:38:16 +000049 paint.setAntiAlias(true);
50 paint.setColor(fillC);
51 canvas->drawCircle(size.fWidth/2, size.fHeight/2, radius, paint);
rmistry@google.comae933ce2012-08-23 18:19:56 +000052
mike@reedtribe.org70e35902012-07-29 20:38:16 +000053 paint.setStyle(SkPaint::kStroke_Style);
54 paint.setStrokeWidth(stroke);
55 paint.setColor(SK_ColorBLACK);
56 canvas->drawCircle(size.fWidth/2, size.fHeight/2, radius, paint);
57}
58
commit-bot@chromium.orgdfec28d2013-07-23 15:52:16 +000059static void test_surface(SkCanvas* canvas, SkSurface* surf, bool usePaint) {
mike@reedtribe.org70e35902012-07-29 20:38:16 +000060 drawContents(surf, SK_ColorRED);
reed9ce9d672016-03-17 10:51:11 -070061 sk_sp<SkImage> imgR = surf->makeImageSnapshot();
mike@reedtribe.org70e35902012-07-29 20:38:16 +000062
reed@google.com97af1a62012-08-28 12:19:02 +000063 if (true) {
reed9ce9d672016-03-17 10:51:11 -070064 sk_sp<SkImage> imgR2 = surf->makeImageSnapshot();
reed@google.com97af1a62012-08-28 12:19:02 +000065 SkASSERT(imgR == imgR2);
reed@google.com97af1a62012-08-28 12:19:02 +000066 }
67
mike@reedtribe.org70e35902012-07-29 20:38:16 +000068 drawContents(surf, SK_ColorGREEN);
reed9ce9d672016-03-17 10:51:11 -070069 sk_sp<SkImage> imgG = surf->makeImageSnapshot();
mike@reedtribe.org70e35902012-07-29 20:38:16 +000070
reed@google.com97af1a62012-08-28 12:19:02 +000071 // since we've drawn after we snapped imgR, imgG will be a different obj
72 SkASSERT(imgR != imgG);
73
mike@reedtribe.org70e35902012-07-29 20:38:16 +000074 drawContents(surf, SK_ColorBLUE);
75
mike@reedtribe.orgd2782ed2012-07-31 02:45:15 +000076 SkPaint paint;
77// paint.setFilterBitmap(true);
78// paint.setAlpha(0x80);
79
reedfe630452016-03-25 09:08:00 -070080 canvas->drawImage(imgR, 0, 0, usePaint ? &paint : nullptr);
81 canvas->drawImage(imgG, 0, 80, usePaint ? &paint : nullptr);
halcanary96fcdcc2015-08-27 07:41:13 -070082 surf->draw(canvas, 0, 160, usePaint ? &paint : nullptr);
commit-bot@chromium.orgdfec28d2013-07-23 15:52:16 +000083
84 SkRect src1, src2, src3;
85 src1.iset(0, 0, surf->width(), surf->height());
skia.committer@gmail.com7f1af502013-07-24 07:01:12 +000086 src2.iset(-surf->width() / 2, -surf->height() / 2,
commit-bot@chromium.orgdfec28d2013-07-23 15:52:16 +000087 surf->width(), surf->height());
88 src3.iset(0, 0, surf->width() / 2, surf->height() / 2);
89
90 SkRect dst1, dst2, dst3, dst4;
91 dst1.set(0, 240, 65, 305);
92 dst2.set(0, 320, 65, 385);
93 dst3.set(0, 400, 65, 465);
94 dst4.set(0, 480, 65, 545);
95
reedfe630452016-03-25 09:08:00 -070096 canvas->drawImageRect(imgR, src1, dst1, usePaint ? &paint : nullptr);
97 canvas->drawImageRect(imgG, src2, dst2, usePaint ? &paint : nullptr);
98 canvas->drawImageRect(imgR, src3, dst3, usePaint ? &paint : nullptr);
99 canvas->drawImageRect(imgG, dst4, usePaint ? &paint : nullptr);
mike@reedtribe.org70e35902012-07-29 20:38:16 +0000100}
101
102class ImageGM : public skiagm::GM {
103 void* fBuffer;
reed@google.com58b21ec2012-07-30 18:20:12 +0000104 size_t fBufferSize;
mike@reedtribe.org70e35902012-07-29 20:38:16 +0000105 SkSize fSize;
106 enum {
107 W = 64,
108 H = 64,
109 RB = W * 4 + 8,
110 };
111public:
112 ImageGM() {
reed@google.com58b21ec2012-07-30 18:20:12 +0000113 fBufferSize = RB * H;
114 fBuffer = sk_malloc_throw(fBufferSize);
mike@reedtribe.org70e35902012-07-29 20:38:16 +0000115 fSize.set(SkIntToScalar(W), SkIntToScalar(H));
116 }
rmistry@google.comae933ce2012-08-23 18:19:56 +0000117
Brian Salomond3b65972017-03-22 12:05:03 -0400118 ~ImageGM() override {
mike@reedtribe.org70e35902012-07-29 20:38:16 +0000119 sk_free(fBuffer);
120 }
rmistry@google.comae933ce2012-08-23 18:19:56 +0000121
mike@reedtribe.org70e35902012-07-29 20:38:16 +0000122protected:
mtklein36352bf2015-03-25 18:17:31 -0700123 SkString onShortName() override {
robertphillips@google.com97b6b072012-10-31 14:48:39 +0000124 return SkString("image-surface");
mike@reedtribe.org70e35902012-07-29 20:38:16 +0000125 }
rmistry@google.comae933ce2012-08-23 18:19:56 +0000126
mtklein36352bf2015-03-25 18:17:31 -0700127 SkISize onISize() override {
commit-bot@chromium.orgdfec28d2013-07-23 15:52:16 +0000128 return SkISize::Make(960, 1200);
mike@reedtribe.org70e35902012-07-29 20:38:16 +0000129 }
rmistry@google.comae933ce2012-08-23 18:19:56 +0000130
mtklein36352bf2015-03-25 18:17:31 -0700131 void onDraw(SkCanvas* canvas) override {
mike@reedtribe.orgd829b5c2012-07-31 03:57:11 +0000132 drawJpeg(canvas, this->getISize());
133
mike@reedtribe.orgd2782ed2012-07-31 02:45:15 +0000134 canvas->scale(2, 2);
135
mtkleindbfd7ab2016-09-01 11:24:54 -0700136 const char* kLabel1 = "Original Img";
137 const char* kLabel2 = "Modified Img";
138 const char* kLabel3 = "Cur Surface";
139 const char* kLabel4 = "Full Crop";
140 const char* kLabel5 = "Over-crop";
141 const char* kLabel6 = "Upper-left";
142 const char* kLabel7 = "No Crop";
robertphillips@google.com97b6b072012-10-31 14:48:39 +0000143
mtkleindbfd7ab2016-09-01 11:24:54 -0700144 const char* kLabel8 = "Pre-Alloc Img";
145 const char* kLabel9 = "New Alloc Img";
146 const char* kLabel10 = "GPU";
robertphillips@google.com97b6b072012-10-31 14:48:39 +0000147
148 SkPaint textPaint;
commit-bot@chromium.orgcae54f12014-04-11 18:34:35 +0000149 textPaint.setAntiAlias(true);
caryclark1818acb2015-07-24 12:09:25 -0700150 sk_tool_utils::set_portable_typeface(&textPaint);
commit-bot@chromium.orgcae54f12014-04-11 18:34:35 +0000151 textPaint.setTextSize(8);
robertphillips@google.com97b6b072012-10-31 14:48:39 +0000152
153 canvas->drawText(kLabel1, strlen(kLabel1), 10, 60, textPaint);
154 canvas->drawText(kLabel2, strlen(kLabel2), 10, 140, textPaint);
155 canvas->drawText(kLabel3, strlen(kLabel3), 10, 220, textPaint);
commit-bot@chromium.orgdfec28d2013-07-23 15:52:16 +0000156 canvas->drawText(kLabel4, strlen(kLabel4), 10, 300, textPaint);
157 canvas->drawText(kLabel5, strlen(kLabel5), 10, 380, textPaint);
158 canvas->drawText(kLabel6, strlen(kLabel6), 10, 460, textPaint);
159 canvas->drawText(kLabel7, strlen(kLabel7), 10, 540, textPaint);
robertphillips@google.com97b6b072012-10-31 14:48:39 +0000160
commit-bot@chromium.orgdfec28d2013-07-23 15:52:16 +0000161 canvas->drawText(kLabel8, strlen(kLabel8), 80, 10, textPaint);
162 canvas->drawText(kLabel9, strlen(kLabel9), 160, 10, textPaint);
reeda9cb8712015-01-16 14:21:40 -0800163 canvas->drawText(kLabel10, strlen(kLabel10), 265, 10, textPaint);
robertphillips@google.com97b6b072012-10-31 14:48:39 +0000164
165 canvas->translate(80, 20);
166
reed@google.com58b21ec2012-07-30 18:20:12 +0000167 // since we draw into this directly, we need to start fresh
168 sk_bzero(fBuffer, fBufferSize);
169
commit-bot@chromium.org32678d92014-01-15 02:38:22 +0000170 SkImageInfo info = SkImageInfo::MakeN32Premul(W, H);
reede8f30622016-03-23 18:59:25 -0700171 sk_sp<SkSurface> surf0(SkSurface::MakeRasterDirect(info, fBuffer, RB));
172 sk_sp<SkSurface> surf1(SkSurface::MakeRaster(info));
173 sk_sp<SkSurface> surf2; // gpu
robertphillips@google.com97b6b072012-10-31 14:48:39 +0000174
reeda9cb8712015-01-16 14:21:40 -0800175#if SK_SUPPORT_GPU
reede8f30622016-03-23 18:59:25 -0700176 surf2 = SkSurface::MakeRenderTarget(canvas->getGrContext(), SkBudgeted::kNo, info);
robertphillips@google.com97b6b072012-10-31 14:48:39 +0000177#endif
mike@reedtribe.org70e35902012-07-29 20:38:16 +0000178
reede8f30622016-03-23 18:59:25 -0700179 test_surface(canvas, surf0.get(), true);
mike@reedtribe.org70e35902012-07-29 20:38:16 +0000180 canvas->translate(80, 0);
reede8f30622016-03-23 18:59:25 -0700181 test_surface(canvas, surf1.get(), true);
reeda9cb8712015-01-16 14:21:40 -0800182 if (surf2) {
robertphillips@google.com97b6b072012-10-31 14:48:39 +0000183 canvas->translate(80, 0);
reede8f30622016-03-23 18:59:25 -0700184 test_surface(canvas, surf2.get(), true);
robertphillips@google.com97b6b072012-10-31 14:48:39 +0000185 }
mike@reedtribe.org70e35902012-07-29 20:38:16 +0000186 }
rmistry@google.comae933ce2012-08-23 18:19:56 +0000187
mike@reedtribe.org70e35902012-07-29 20:38:16 +0000188private:
189 typedef skiagm::GM INHERITED;
190};
reeda9cb8712015-01-16 14:21:40 -0800191DEF_GM( return new ImageGM; )
reed09553032015-11-23 12:32:16 -0800192
193///////////////////////////////////////////////////////////////////////////////////////////////////
194
195#include "SkPictureRecorder.h"
196
197static void draw_pixmap(SkCanvas* canvas, const SkPixmap& pmap) {
198 SkBitmap bitmap;
halcanarye36ec872015-12-09 11:36:59 -0800199 bitmap.installPixels(pmap);
reed09553032015-11-23 12:32:16 -0800200 canvas->drawBitmap(bitmap, 0, 0, nullptr);
201}
202
203static void show_scaled_pixels(SkCanvas* canvas, SkImage* image) {
204 SkAutoCanvasRestore acr(canvas, true);
205
206 canvas->drawImage(image, 0, 0, nullptr);
207 canvas->translate(110, 10);
208
209 const SkImageInfo info = SkImageInfo::MakeN32Premul(40, 40);
210 SkAutoPixmapStorage storage;
211 storage.alloc(info);
212
213 const SkImage::CachingHint chints[] = {
reed6868c3f2015-11-24 11:44:47 -0800214 SkImage::kAllow_CachingHint, SkImage::kDisallow_CachingHint,
reed09553032015-11-23 12:32:16 -0800215 };
216 const SkFilterQuality qualities[] = {
217 kNone_SkFilterQuality, kLow_SkFilterQuality, kMedium_SkFilterQuality, kHigh_SkFilterQuality,
218 };
219
220 for (auto ch : chints) {
221 canvas->save();
222 for (auto q : qualities) {
223 if (image->scalePixels(storage, q, ch)) {
224 draw_pixmap(canvas, storage);
225 }
226 canvas->translate(70, 0);
227 }
228 canvas->restore();
229 canvas->translate(0, 45);
230 }
231}
232
233static void draw_contents(SkCanvas* canvas) {
234 SkPaint paint;
235 paint.setStyle(SkPaint::kStroke_Style);
236 paint.setStrokeWidth(20);
237 canvas->drawCircle(50, 50, 35, paint);
238}
239
reed9ce9d672016-03-17 10:51:11 -0700240static sk_sp<SkImage> make_raster(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) {
reede8f30622016-03-23 18:59:25 -0700241 auto surface(SkSurface::MakeRaster(info));
reed7850eb22015-12-02 14:19:47 -0800242 draw(surface->getCanvas());
reed9ce9d672016-03-17 10:51:11 -0700243 return surface->makeImageSnapshot();
reed09553032015-11-23 12:32:16 -0800244}
245
reed9ce9d672016-03-17 10:51:11 -0700246static sk_sp<SkImage> make_picture(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) {
reed09553032015-11-23 12:32:16 -0800247 SkPictureRecorder recorder;
reed7850eb22015-12-02 14:19:47 -0800248 draw(recorder.beginRecording(SkRect::MakeIWH(info.width(), info.height())));
reedca2622b2016-03-18 07:25:55 -0700249 return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(),
Matt Sarette94255d2017-01-09 12:38:59 -0500250 info.dimensions(), nullptr, nullptr, SkImage::BitDepth::kU8,
Matt Sarett77a7a1b2017-02-07 13:56:11 -0500251 SkColorSpace::MakeSRGB());
reed09553032015-11-23 12:32:16 -0800252}
253
reed9ce9d672016-03-17 10:51:11 -0700254static sk_sp<SkImage> make_codec(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) {
255 sk_sp<SkImage> image(make_raster(info, nullptr, draw));
256 sk_sp<SkData> data(image->encode());
257 return SkImage::MakeFromEncoded(data);
reed09553032015-11-23 12:32:16 -0800258}
259
reed9ce9d672016-03-17 10:51:11 -0700260static sk_sp<SkImage> make_gpu(const SkImageInfo& info, GrContext* ctx, void (*draw)(SkCanvas*)) {
reed09553032015-11-23 12:32:16 -0800261 if (!ctx) { return nullptr; }
reede8f30622016-03-23 18:59:25 -0700262 auto surface(SkSurface::MakeRenderTarget(ctx, SkBudgeted::kNo, info));
scroggoe6f0d6e2016-05-13 07:25:44 -0700263 if (!surface) { return nullptr; }
reed7850eb22015-12-02 14:19:47 -0800264 draw(surface->getCanvas());
reed9ce9d672016-03-17 10:51:11 -0700265 return surface->makeImageSnapshot();
reed09553032015-11-23 12:32:16 -0800266}
267
reed9ce9d672016-03-17 10:51:11 -0700268typedef sk_sp<SkImage> (*ImageMakerProc)(const SkImageInfo&, GrContext*, void (*)(SkCanvas*));
reed09553032015-11-23 12:32:16 -0800269
270class ScalePixelsGM : public skiagm::GM {
271public:
272 ScalePixelsGM() {}
273
274protected:
275 SkString onShortName() override {
276 return SkString("scale-pixels");
277 }
278
279 SkISize onISize() override {
280 return SkISize::Make(960, 1200);
281 }
282
283 void onDraw(SkCanvas* canvas) override {
284 const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
285
286 const ImageMakerProc procs[] = {
reed6868c3f2015-11-24 11:44:47 -0800287 make_codec, make_raster, make_picture, make_codec, make_gpu,
reed09553032015-11-23 12:32:16 -0800288 };
289 for (auto& proc : procs) {
reed9ce9d672016-03-17 10:51:11 -0700290 sk_sp<SkImage> image(proc(info, canvas->getGrContext(), draw_contents));
reed09553032015-11-23 12:32:16 -0800291 if (image) {
reed9ce9d672016-03-17 10:51:11 -0700292 show_scaled_pixels(canvas, image.get());
reed09553032015-11-23 12:32:16 -0800293 }
294 canvas->translate(0, 120);
295 }
296 }
halcanary9d524f22016-03-29 09:03:52 -0700297
reed09553032015-11-23 12:32:16 -0800298private:
299 typedef skiagm::GM INHERITED;
300};
301DEF_GM( return new ScalePixelsGM; )
reed7850eb22015-12-02 14:19:47 -0800302
303///////////////////////////////////////////////////////////////////////////////////////////////////
304
Brian Osmane8827d22017-02-07 12:31:02 -0500305DEF_SIMPLE_GM(new_texture_image, canvas, 280, 60) {
306 GrContext* context = canvas->getGrContext();
Brian Osman041f7df2017-02-07 11:23:28 -0500307 if (!context) {
308 skiagm::GM::DrawGpuOnlyMessage(canvas);
309 return;
310 }
311
312 auto render_image = [](SkCanvas* canvas) {
313 canvas->clear(SK_ColorBLUE);
314 SkPaint paint;
315 paint.setColor(SK_ColorRED);
316 canvas->drawRect(SkRect::MakeXYWH(10.f,10.f,10.f,10.f), paint);
317 paint.setColor(SK_ColorGREEN);
318 canvas->drawRect(SkRect::MakeXYWH(30.f,10.f,10.f,10.f), paint);
319 paint.setColor(SK_ColorYELLOW);
320 canvas->drawRect(SkRect::MakeXYWH(10.f,30.f,10.f,10.f), paint);
321 paint.setColor(SK_ColorCYAN);
322 canvas->drawRect(SkRect::MakeXYWH(30.f,30.f,10.f,10.f), paint);
323 };
324
325 static constexpr int kSize = 50;
326 SkBitmap bmp;
327 bmp.allocPixels(SkImageInfo::MakeS32(kSize, kSize, kPremul_SkAlphaType));
328 SkCanvas bmpCanvas(bmp);
329 render_image(&bmpCanvas);
330
331 std::function<sk_sp<SkImage>()> imageFactories[] = {
332 // Create sw raster image.
333 [bmp] {
334 return SkImage::MakeFromBitmap(bmp);
335 },
336 // Create encoded image.
337 [bmp] {
338 sk_sp<SkData> src(
339 sk_tool_utils::EncodeImageToData(bmp, SkEncodedImageFormat::kPNG, 100));
340 return SkImage::MakeFromEncoded(std::move(src));
341 },
Brian Osmane8827d22017-02-07 12:31:02 -0500342 // Create YUV encoded image.
343 [bmp] {
344 sk_sp<SkData> src(
345 sk_tool_utils::EncodeImageToData(bmp, SkEncodedImageFormat::kJPEG, 100));
346 return SkImage::MakeFromEncoded(std::move(src));
347 },
Brian Osman041f7df2017-02-07 11:23:28 -0500348 // Create a picture image.
349 [render_image] {
350 SkPictureRecorder recorder;
351 SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kSize), SkIntToScalar(kSize));
352 render_image(canvas);
Matt Sarett77a7a1b2017-02-07 13:56:11 -0500353 sk_sp<SkColorSpace> srgbColorSpace = SkColorSpace::MakeSRGB();
Brian Osman041f7df2017-02-07 11:23:28 -0500354 return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(),
355 SkISize::Make(kSize, kSize), nullptr, nullptr,
356 SkImage::BitDepth::kU8, srgbColorSpace);
357 },
358 // Create a texture image
359 [context, render_image]() -> sk_sp<SkImage> {
360 auto surface(SkSurface::MakeRenderTarget(context, SkBudgeted::kYes,
361 SkImageInfo::MakeS32(kSize, kSize,
362 kPremul_SkAlphaType)));
363 if (!surface) {
364 return nullptr;
365 }
366 render_image(surface->getCanvas());
367 return surface->makeImageSnapshot();
368 }
369 };
370
371 constexpr SkScalar kPad = 5.f;
372 canvas->translate(kPad, kPad);
373 for (auto factory : imageFactories) {
374 auto image(factory());
Brian Osmane8827d22017-02-07 12:31:02 -0500375 if (image) {
Brian Osman041f7df2017-02-07 11:23:28 -0500376 sk_sp<SkImage> texImage(image->makeTextureImage(context,
377 canvas->imageInfo().colorSpace()));
378 if (texImage) {
379 canvas->drawImage(texImage, 0, 0);
380 }
381 }
Robert Phillips5bea6512017-02-10 08:04:06 -0500382 canvas->translate(kSize + kPad, 0);
Brian Osman041f7df2017-02-07 11:23:28 -0500383 }
384}