VirtualBox

source: vbox/trunk/src/VBox/Main/src-all/DisplayPNGUtil.cpp@ 67954

Last change on this file since 67954 was 62485, checked in by vboxsync, 8 years ago

(C) 2016

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 6.9 KB
Line 
1/* $Id: DisplayPNGUtil.cpp 62485 2016-07-22 18:36:43Z vboxsync $ */
2/** @file
3 * PNG utilities
4 */
5
6/*
7 * Copyright (C) 2010-2016 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#include "Logging.h"
19#include "DisplayImpl.h"
20
21#include <iprt/alloc.h>
22
23#include <png.h>
24
25#define kMaxSizePNG 1024
26
27typedef struct PNGWriteCtx
28{
29 uint8_t *pu8PNG;
30 uint32_t cbPNG;
31 uint32_t cbAllocated;
32 int rc;
33} PNGWriteCtx;
34
35static void PNGAPI png_write_data_fn(png_structp png_ptr, png_bytep p, png_size_t cb)
36{
37 PNGWriteCtx *pCtx = (PNGWriteCtx *)png_get_io_ptr(png_ptr);
38 LogFlowFunc(("png_ptr %p, p %p, cb %d, pCtx %p\n", png_ptr, p, cb, pCtx));
39
40 if (pCtx && RT_SUCCESS(pCtx->rc))
41 {
42 if (pCtx->cbAllocated - pCtx->cbPNG < cb)
43 {
44 uint32_t cbNew = pCtx->cbPNG + (uint32_t)cb;
45 AssertReturnVoidStmt(cbNew > pCtx->cbPNG && cbNew <= _1G, pCtx->rc = VERR_TOO_MUCH_DATA);
46 cbNew = RT_ALIGN_32(cbNew, 4096) + 4096;
47
48 void *pNew = RTMemRealloc(pCtx->pu8PNG, cbNew);
49 if (!pNew)
50 {
51 pCtx->rc = VERR_NO_MEMORY;
52 return;
53 }
54
55 pCtx->pu8PNG = (uint8_t *)pNew;
56 pCtx->cbAllocated = cbNew;
57 }
58
59 memcpy(pCtx->pu8PNG + pCtx->cbPNG, p, cb);
60 pCtx->cbPNG += (uint32_t)cb;
61 }
62}
63
64static void PNGAPI png_output_flush_fn(png_structp png_ptr)
65{
66 NOREF(png_ptr);
67 /* Do nothing. */
68}
69
70int DisplayMakePNG(uint8_t *pu8Data, uint32_t cx, uint32_t cy,
71 uint8_t **ppu8PNG, uint32_t *pcbPNG, uint32_t *pcxPNG, uint32_t *pcyPNG,
72 uint8_t fLimitSize)
73{
74 int rc = VINF_SUCCESS;
75
76 uint8_t * volatile pu8Bitmap = NULL; /* gcc setjmp warning */
77 uint32_t volatile cbBitmap = 0; /* gcc setjmp warning */
78 uint32_t volatile cxBitmap = 0; /* gcc setjmp warning */
79 uint32_t volatile cyBitmap = 0; /* gcc setjmp warning */
80
81 if (!fLimitSize || (cx < kMaxSizePNG && cy < kMaxSizePNG))
82 {
83 /* Save unscaled screenshot. */
84 pu8Bitmap = pu8Data;
85 cbBitmap = cx * 4 * cy;
86 cxBitmap = cx;
87 cyBitmap = cy;
88 }
89 else
90 {
91 /* Large screenshot, scale. */
92 if (cx > cy)
93 {
94 cxBitmap = kMaxSizePNG;
95 cyBitmap = (kMaxSizePNG * cy) / cx;
96 }
97 else
98 {
99 cyBitmap = kMaxSizePNG;
100 cxBitmap = (kMaxSizePNG * cx) / cy;
101 }
102
103 cbBitmap = cxBitmap * 4 * cyBitmap;
104
105 pu8Bitmap = (uint8_t *)RTMemAlloc(cbBitmap);
106
107 if (pu8Bitmap)
108 {
109 uint8_t *dst = pu8Bitmap;
110 uint8_t *src = pu8Data;
111 int dstW = cxBitmap;
112 int dstH = cyBitmap;
113 int srcW = cx;
114 int srcH = cy;
115 int iDeltaLine = cx * 4;
116
117 BitmapScale32 (dst,
118 dstW, dstH,
119 src,
120 iDeltaLine,
121 srcW, srcH);
122 }
123 else
124 {
125 rc = VERR_NO_MEMORY;
126 }
127 }
128
129 LogFlowFunc(("%dx%d -> %dx%d\n", cx, cy, cxBitmap, cyBitmap));
130
131 if (RT_SUCCESS(rc))
132 {
133 png_bytep *row_pointers = (png_bytep *)RTMemAlloc(cyBitmap * sizeof(png_bytep));
134 if (row_pointers)
135 {
136 png_infop info_ptr = NULL;
137 png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
138 (png_voidp)NULL, /* error/warning context pointer */
139 (png_error_ptr)NULL, /* error function */
140 (png_error_ptr)NULL /* warning function */);
141 if (png_ptr)
142 {
143 info_ptr = png_create_info_struct(png_ptr);
144 if (info_ptr)
145 {
146 if (!setjmp(png_jmpbuf(png_ptr)))
147 {
148 PNGWriteCtx ctx;
149 ctx.pu8PNG = NULL;
150 ctx.cbPNG = 0;
151 ctx.cbAllocated = 0;
152 ctx.rc = VINF_SUCCESS;
153
154 png_set_write_fn(png_ptr,
155 (png_voidp)&ctx,
156 png_write_data_fn,
157 png_output_flush_fn);
158
159 png_set_IHDR(png_ptr, info_ptr,
160 cxBitmap, cyBitmap,
161 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
162 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
163
164 png_bytep row_pointer = (png_bytep)pu8Bitmap;
165 unsigned i = 0;
166 for (; i < cyBitmap; i++, row_pointer += cxBitmap * 4)
167 {
168 row_pointers[i] = row_pointer;
169 }
170 png_set_rows(png_ptr, info_ptr, &row_pointers[0]);
171
172 png_write_info(png_ptr, info_ptr);
173 png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
174 png_set_bgr(png_ptr);
175
176 if (png_get_valid(png_ptr, info_ptr, PNG_INFO_IDAT))
177 png_write_image(png_ptr, png_get_rows(png_ptr, info_ptr));
178
179 png_write_end(png_ptr, info_ptr);
180
181 rc = ctx.rc;
182
183 if (RT_SUCCESS(rc))
184 {
185 *ppu8PNG = ctx.pu8PNG;
186 *pcbPNG = ctx.cbPNG;
187 *pcxPNG = cxBitmap;
188 *pcyPNG = cyBitmap;
189 LogFlowFunc(("PNG %d bytes, bitmap %d bytes\n", ctx.cbPNG, cbBitmap));
190 }
191 }
192 else
193 {
194 rc = VERR_GENERAL_FAILURE; /* Something within libpng. */
195 }
196 }
197 else
198 {
199 rc = VERR_NO_MEMORY;
200 }
201
202 png_destroy_write_struct(&png_ptr, info_ptr ? &info_ptr
203 : (png_infopp)NULL);
204 }
205 else
206 {
207 rc = VERR_NO_MEMORY;
208 }
209
210 RTMemFree(row_pointers);
211 }
212 else
213 {
214 rc = VERR_NO_MEMORY;
215 }
216 }
217
218 if (pu8Bitmap && pu8Bitmap != pu8Data)
219 {
220 RTMemFree(pu8Bitmap);
221 }
222
223 return rc;
224
225}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette