1 /*
2  * Copyright (c) 2012-2014, Linux Foundation. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *   * Redistributions of source code must retain the above copyright
8  *     notice, this list of conditions and the following disclaimer.
9  *   * Redistributions in binary form must reproduce the above
10  *     copyright notice, this list of conditions and the following
11  *     disclaimer in the documentation and/or other materials provided
12  *     with the distribution.
13  *   * Neither the name of Linux Foundation nor the names of its
14  *     contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
18  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
21  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
24  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
26  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29 
30 #ifndef LOG_TAG
31 #define LOG_TAG "qsfdump"
32 #endif
33 #define LOG_NDEBUG 0
34 #include <hwc_utils.h>
35 #include <hwc_dump_layers.h>
36 #include <cutils/log.h>
37 #include <sys/stat.h>
38 #include <comptype.h>
39 #ifdef QCOM_BSP
40 #include <SkBitmap.h>
41 #include <SkImageEncoder.h>
42 #endif
43 #ifdef STDC_FORMAT_MACROS
44 #include <inttypes.h>
45 #endif
46 
47 namespace qhwc {
48 
49 // MAX_ALLOWED_FRAMEDUMPS must be capped to (LONG_MAX - 1)
50 // 60fps => 216000 frames per hour
51 // Below setting of 216000 * 24 * 7 => 1 week or 168 hours of capture.
52   enum {
53     MAX_ALLOWED_FRAMEDUMPS = (216000 * 24 * 7)
54   };
55 
56 bool HwcDebug::sDumpEnable = false;
57 
HwcDebug(uint32_t dpy)58 HwcDebug::HwcDebug(uint32_t dpy):
59   mDumpCntLimRaw(0),
60   mDumpCntrRaw(1),
61   mDumpCntLimPng(0),
62   mDumpCntrPng(1),
63   mDpy(dpy) {
64     char dumpPropStr[PROPERTY_VALUE_MAX];
65     if(mDpy) {
66         strlcpy(mDisplayName, "external", sizeof(mDisplayName));
67     } else {
68         strlcpy(mDisplayName, "primary", sizeof(mDisplayName));
69     }
70     snprintf(mDumpPropKeyDisplayType, sizeof(mDumpPropKeyDisplayType),
71              "debug.sf.dump.%s", (char *)mDisplayName);
72 
73     if ((property_get("debug.sf.dump.enable", dumpPropStr, NULL) > 0)) {
74         if(!strncmp(dumpPropStr, "true", strlen("true"))) {
75             sDumpEnable = true;
76         }
77     }
78 }
79 
dumpLayers(hwc_display_contents_1_t * list)80 void HwcDebug::dumpLayers(hwc_display_contents_1_t* list)
81 {
82     // Check need for dumping layers for debugging.
83     if (UNLIKELY(sDumpEnable) && UNLIKELY(needToDumpLayers()) && LIKELY(list)) {
84         logHwcProps(list->flags);
85         for (size_t i = 0; i < list->numHwLayers; i++) {
86             logLayer(i, list->hwLayers);
87             dumpLayer(i, list->hwLayers);
88         }
89     }
90 }
91 
needToDumpLayers()92 bool HwcDebug::needToDumpLayers()
93 {
94     bool bDumpLayer = false;
95     char dumpPropStr[PROPERTY_VALUE_MAX];
96     // Enable primary dump and disable external dump by default.
97     bool bDumpEnable = !mDpy;
98     time_t timeNow;
99     tm dumpTime;
100 
101     // Override the bDumpEnable based on the property value, if the property
102     // is present in the build.prop file.
103     if ((property_get(mDumpPropKeyDisplayType, dumpPropStr, NULL) > 0)) {
104         if(!strncmp(dumpPropStr, "true", strlen("true")))
105             bDumpEnable = true;
106         else
107             bDumpEnable = false;
108     }
109 
110     if (false == bDumpEnable)
111         return false;
112 
113     time(&timeNow);
114     localtime_r(&timeNow, &dumpTime);
115 
116     if ((property_get("debug.sf.dump.png", dumpPropStr, NULL) > 0) &&
117             (strncmp(dumpPropStr, mDumpPropStrPng, PROPERTY_VALUE_MAX - 1))) {
118         // Strings exist & not equal implies it has changed, so trigger a dump
119         strlcpy(mDumpPropStrPng, dumpPropStr, sizeof(mDumpPropStrPng));
120         mDumpCntLimPng = atoi(dumpPropStr);
121         if (mDumpCntLimPng > MAX_ALLOWED_FRAMEDUMPS) {
122             ALOGW("Warning: Using debug.sf.dump.png %d (= max)",
123                 MAX_ALLOWED_FRAMEDUMPS);
124             mDumpCntLimPng = MAX_ALLOWED_FRAMEDUMPS;
125         }
126         mDumpCntLimPng = (mDumpCntLimPng < 0) ? 0: mDumpCntLimPng;
127         if (mDumpCntLimPng) {
128             snprintf(mDumpDirPng, sizeof(mDumpDirPng),
129                     "/data/sfdump.png.%04d.%02d.%02d.%02d.%02d.%02d",
130                     dumpTime.tm_year + 1900, dumpTime.tm_mon + 1,
131                     dumpTime.tm_mday, dumpTime.tm_hour,
132                     dumpTime.tm_min, dumpTime.tm_sec);
133             if (0 == mkdir(mDumpDirPng, 0777))
134                 mDumpCntrPng = 0;
135             else {
136                 ALOGE("Error: %s. Failed to create sfdump directory: %s",
137                     strerror(errno), mDumpDirPng);
138                 mDumpCntrPng = mDumpCntLimPng + 1;
139             }
140         }
141     }
142 
143     if (mDumpCntrPng <= mDumpCntLimPng)
144         mDumpCntrPng++;
145 
146     if ((property_get("debug.sf.dump", dumpPropStr, NULL) > 0) &&
147             (strncmp(dumpPropStr, mDumpPropStrRaw, PROPERTY_VALUE_MAX - 1))) {
148         // Strings exist & not equal implies it has changed, so trigger a dump
149         strlcpy(mDumpPropStrRaw, dumpPropStr, sizeof(mDumpPropStrRaw));
150         mDumpCntLimRaw = atoi(dumpPropStr);
151         if (mDumpCntLimRaw > MAX_ALLOWED_FRAMEDUMPS) {
152             ALOGW("Warning: Using debug.sf.dump %d (= max)",
153                 MAX_ALLOWED_FRAMEDUMPS);
154             mDumpCntLimRaw = MAX_ALLOWED_FRAMEDUMPS;
155         }
156         mDumpCntLimRaw = (mDumpCntLimRaw < 0) ? 0: mDumpCntLimRaw;
157         if (mDumpCntLimRaw) {
158             snprintf(mDumpDirRaw, sizeof(mDumpDirRaw),
159                     "/data/sfdump.raw.%04d.%02d.%02d.%02d.%02d.%02d",
160                     dumpTime.tm_year + 1900, dumpTime.tm_mon + 1,
161                     dumpTime.tm_mday, dumpTime.tm_hour,
162                     dumpTime.tm_min, dumpTime.tm_sec);
163             if (0 == mkdir(mDumpDirRaw, 0777))
164                 mDumpCntrRaw = 0;
165             else {
166                 ALOGE("Error: %s. Failed to create sfdump directory: %s",
167                     strerror(errno), mDumpDirRaw);
168                 mDumpCntrRaw = mDumpCntLimRaw + 1;
169             }
170         }
171     }
172 
173     if (mDumpCntrRaw <= mDumpCntLimRaw)
174         mDumpCntrRaw++;
175 
176     bDumpLayer = (mDumpCntLimPng || mDumpCntLimRaw)? true : false;
177     return bDumpLayer;
178 }
179 
logHwcProps(uint32_t listFlags)180 void HwcDebug::logHwcProps(uint32_t listFlags)
181 {
182     static int hwcModuleCompType = -1;
183     static int sMdpCompMaxLayers = 0;
184     static String8 hwcModuleCompTypeLog("");
185     if (-1 == hwcModuleCompType) {
186         // One time stuff
187         char mdpCompPropStr[PROPERTY_VALUE_MAX];
188         if (property_get("debug.mdpcomp.maxlayer", mdpCompPropStr, NULL) > 0) {
189             sMdpCompMaxLayers = atoi(mdpCompPropStr);
190         }
191         hwcModuleCompType =
192             qdutils::QCCompositionType::getInstance().getCompositionType();
193         hwcModuleCompTypeLog.appendFormat("%s%s%s%s%s%s",
194             // Is hwc module composition type now a bit-field?!
195             (hwcModuleCompType == qdutils::COMPOSITION_TYPE_GPU)?
196                 "[GPU]": "",
197             (hwcModuleCompType & qdutils::COMPOSITION_TYPE_MDP)?
198                 "[MDP]": "",
199             (hwcModuleCompType & qdutils::COMPOSITION_TYPE_C2D)?
200                 "[C2D]": "",
201             (hwcModuleCompType & qdutils::COMPOSITION_TYPE_CPU)?
202                 "[CPU]": "",
203             (hwcModuleCompType & qdutils::COMPOSITION_TYPE_DYN)?
204                 "[DYN]": "",
205             (hwcModuleCompType >= (qdutils::COMPOSITION_TYPE_DYN << 1))?
206                 "[???]": "");
207     }
208     ALOGI("Display[%s] Layer[*] %s-HwcModuleCompType, %d-layer MdpComp %s",
209          mDisplayName, hwcModuleCompTypeLog.string(), sMdpCompMaxLayers,
210         (listFlags & HWC_GEOMETRY_CHANGED)? "[HwcList Geometry Changed]": "");
211 }
212 
logLayer(size_t layerIndex,hwc_layer_1_t hwLayers[])213 void HwcDebug::logLayer(size_t layerIndex, hwc_layer_1_t hwLayers[])
214 {
215     if (NULL == hwLayers) {
216         ALOGE("Display[%s] Layer[%zu] Error. No hwc layers to log.",
217             mDisplayName, layerIndex);
218         return;
219     }
220 
221     hwc_layer_1_t *layer = &hwLayers[layerIndex];
222     hwc_rect_t sourceCrop = integerizeSourceCrop(layer->sourceCropf);
223     hwc_rect_t displayFrame = layer->displayFrame;
224     size_t numHwcRects = layer->visibleRegionScreen.numRects;
225     hwc_rect_t const *hwcRects = layer->visibleRegionScreen.rects;
226     private_handle_t *hnd = (private_handle_t *)layer->handle;
227 
228     char pixFormatStr[32] = "None";
229     String8 hwcVisRegsScrLog("[None]");
230 
231     for (size_t i = 0 ; (hwcRects && (i < numHwcRects)); i++) {
232         if (0 == i)
233             hwcVisRegsScrLog.clear();
234         hwcVisRegsScrLog.appendFormat("[%dl, %dt, %dr, %db]",
235                                         hwcRects[i].left, hwcRects[i].top,
236                                         hwcRects[i].right, hwcRects[i].bottom);
237     }
238 
239     if (hnd)
240         getHalPixelFormatStr(hnd->format, pixFormatStr);
241 
242     // Log Line 1
243     ALOGI("Display[%s] Layer[%zu] SrcBuff[%dx%d] SrcCrop[%dl, %dt, %dr, %db] "
244         "DispFrame[%dl, %dt, %dr, %db] VisRegsScr%s", mDisplayName, layerIndex,
245         (hnd)? getWidth(hnd) : -1, (hnd)? getHeight(hnd) : -1,
246         sourceCrop.left, sourceCrop.top,
247         sourceCrop.right, sourceCrop.bottom,
248         displayFrame.left, displayFrame.top,
249         displayFrame.right, displayFrame.bottom,
250         hwcVisRegsScrLog.string());
251     // Log Line 2
252     ALOGI("Display[%s] Layer[%zu] LayerCompType = %s, Format = %s, "
253         "Orientation = %s, Flags = %s%s%s, Hints = %s%s%s, "
254         "Blending = %s%s%s", mDisplayName, layerIndex,
255         (layer->compositionType == HWC_FRAMEBUFFER)? "Framebuffer(GPU)":
256             (layer->compositionType == HWC_OVERLAY)? "Overlay":
257             (layer->compositionType == HWC_BACKGROUND)? "Background":"???",
258          pixFormatStr,
259          (layer->transform == 0)? "ROT_0":
260              (layer->transform == HWC_TRANSFORM_FLIP_H)? "FLIP_H":
261              (layer->transform == HWC_TRANSFORM_FLIP_V)? "FLIP_V":
262              (layer->transform == HWC_TRANSFORM_ROT_90)? "ROT_90":
263                                                         "ROT_INVALID",
264          (layer->flags)? "": "[None]",
265          (layer->flags & HWC_SKIP_LAYER)? "[Skip layer]":"",
266          (layer->flags & qhwc::HWC_MDPCOMP)? "[MDP Comp]":"",
267          (layer->hints)? "":"[None]",
268          (layer->hints & HWC_HINT_TRIPLE_BUFFER)? "[Triple Buffer]":"",
269          (layer->hints & HWC_HINT_CLEAR_FB)? "[Clear FB]":"",
270          (layer->blending == HWC_BLENDING_NONE)? "[None]":"",
271          (layer->blending == HWC_BLENDING_PREMULT)? "[PreMult]":"",
272          (layer->blending == HWC_BLENDING_COVERAGE)? "[Coverage]":"");
273 }
274 
dumpLayer(size_t layerIndex,hwc_layer_1_t hwLayers[])275 void HwcDebug::dumpLayer(size_t layerIndex, hwc_layer_1_t hwLayers[])
276 {
277     char dumpLogStrPng[128] = "";
278     char dumpLogStrRaw[128] = "";
279     bool needDumpPng = (mDumpCntrPng <= mDumpCntLimPng)? true:false;
280     bool needDumpRaw = (mDumpCntrRaw <= mDumpCntLimRaw)? true:false;
281 
282     if (needDumpPng) {
283         snprintf(dumpLogStrPng, sizeof(dumpLogStrPng),
284             "[png-dump-frame: %03d of %03d]", mDumpCntrPng,
285             mDumpCntLimPng);
286     }
287     if (needDumpRaw) {
288         snprintf(dumpLogStrRaw, sizeof(dumpLogStrRaw),
289             "[raw-dump-frame: %03d of %03d]", mDumpCntrRaw,
290             mDumpCntLimRaw);
291     }
292 
293     if (!(needDumpPng || needDumpRaw))
294         return;
295 
296     if (NULL == hwLayers) {
297         ALOGE("Display[%s] Layer[%zu] %s%s Error: No hwc layers to dump.",
298             mDisplayName, layerIndex, dumpLogStrRaw, dumpLogStrPng);
299         return;
300     }
301 
302     hwc_layer_1_t *layer = &hwLayers[layerIndex];
303     private_handle_t *hnd = (private_handle_t *)layer->handle;
304     char pixFormatStr[32] = "None";
305 
306     if (NULL == hnd) {
307         ALOGI("Display[%s] Layer[%zu] %s%s Skipping dump: Bufferless layer.",
308             mDisplayName, layerIndex, dumpLogStrRaw, dumpLogStrPng);
309         return;
310     }
311 
312     getHalPixelFormatStr(hnd->format, pixFormatStr);
313 #ifdef QCOM_BSP
314     if (needDumpPng && hnd->base) {
315         bool bResult = false;
316         char dumpFilename[PATH_MAX];
317         SkBitmap::Config tempSkBmpConfig = SkBitmap::kNo_Config;
318         snprintf(dumpFilename, sizeof(dumpFilename),
319             "%s/sfdump%03d.layer%zu.%s.png", mDumpDirPng,
320             mDumpCntrPng, layerIndex, mDisplayName);
321 
322         switch (hnd->format) {
323             case HAL_PIXEL_FORMAT_RGBA_8888:
324             case HAL_PIXEL_FORMAT_RGBX_8888:
325             case HAL_PIXEL_FORMAT_BGRA_8888:
326                 tempSkBmpConfig = SkBitmap::kARGB_8888_Config;
327                 break;
328             case HAL_PIXEL_FORMAT_RGB_565:
329                 tempSkBmpConfig = SkBitmap::kRGB_565_Config;
330                 break;
331             case HAL_PIXEL_FORMAT_RGB_888:
332             default:
333                 tempSkBmpConfig = SkBitmap::kNo_Config;
334                 break;
335         }
336         if (SkBitmap::kNo_Config != tempSkBmpConfig) {
337             SkImageInfo info = SkImageInfo::Make(getWidth(hnd), getHeight(hnd),
338                                                  tempSkBmpColor, kIgnore_SkAlphaType);
339             SkPixmap pixmap(info, (const void*)hnd->base, info.minRowBytes());
340             SkFILEWStream file(dumpFilename);
341             bResult = SkEncodeImage(&file, pixmap, SkEncodedImageFormat::kPNG, 100);
342             ALOGI("Display[%s] Layer[%zu] %s Dump to %s: %s",
343                 mDisplayName, layerIndex, dumpLogStrPng,
344                 dumpFilename, bResult ? "Success" : "Fail");
345         } else {
346             ALOGI("Display[%s] Layer[%zu] %s Skipping dump: Unsupported layer"
347                 " format %s for png encoder",
348                 mDisplayName, layerIndex, dumpLogStrPng, pixFormatStr);
349         }
350     }
351 #endif
352     if (needDumpRaw && hnd->base) {
353         char dumpFilename[PATH_MAX];
354         bool bResult = false;
355         snprintf(dumpFilename, sizeof(dumpFilename),
356             "%s/sfdump%03d.layer%zu.%dx%d.%s.%s.raw",
357             mDumpDirRaw, mDumpCntrRaw,
358             layerIndex, getWidth(hnd), getHeight(hnd),
359             pixFormatStr, mDisplayName);
360         FILE* fp = fopen(dumpFilename, "w+");
361         if (NULL != fp) {
362             bResult = (bool) fwrite((void*)hnd->base, hnd->size, 1, fp);
363             fclose(fp);
364         }
365         ALOGI("Display[%s] Layer[%zu] %s Dump to %s: %s",
366             mDisplayName, layerIndex, dumpLogStrRaw,
367             dumpFilename, bResult ? "Success" : "Fail");
368     }
369 }
370 
getHalPixelFormatStr(int format,char pixFormatStr[])371 void HwcDebug::getHalPixelFormatStr(int format, char pixFormatStr[])
372 {
373     if (!pixFormatStr)
374         return;
375 
376     switch(format) {
377         case HAL_PIXEL_FORMAT_RGBA_8888:
378             strlcpy(pixFormatStr, "RGBA_8888", sizeof(pixFormatStr));
379             break;
380         case HAL_PIXEL_FORMAT_RGBX_8888:
381             strlcpy(pixFormatStr, "RGBX_8888", sizeof(pixFormatStr));
382             break;
383         case HAL_PIXEL_FORMAT_RGB_888:
384             strlcpy(pixFormatStr, "RGB_888", sizeof(pixFormatStr));
385             break;
386         case HAL_PIXEL_FORMAT_RGB_565:
387             strlcpy(pixFormatStr, "RGB_565", sizeof(pixFormatStr));
388             break;
389         case HAL_PIXEL_FORMAT_BGRA_8888:
390             strlcpy(pixFormatStr, "BGRA_8888", sizeof(pixFormatStr));
391             break;
392         case HAL_PIXEL_FORMAT_YV12:
393             strlcpy(pixFormatStr, "YV12", sizeof(pixFormatStr));
394             break;
395         case HAL_PIXEL_FORMAT_YCbCr_422_SP:
396             strlcpy(pixFormatStr, "YCbCr_422_SP_NV16", sizeof(pixFormatStr));
397             break;
398         case HAL_PIXEL_FORMAT_YCrCb_420_SP:
399             strlcpy(pixFormatStr, "YCrCb_420_SP_NV21", sizeof(pixFormatStr));
400             break;
401         case HAL_PIXEL_FORMAT_YCbCr_422_I:
402             strlcpy(pixFormatStr, "YCbCr_422_I_YUY2", sizeof(pixFormatStr));
403             break;
404         case HAL_PIXEL_FORMAT_YCrCb_422_I:
405             strlcpy(pixFormatStr, "YCrCb_422_I_YVYU", sizeof(pixFormatStr));
406             break;
407         case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
408             strlcpy(pixFormatStr, "NV12_ENCODEABLE", sizeof(pixFormatStr));
409             break;
410         case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
411             strlcpy(pixFormatStr, "YCbCr_420_SP_TILED_TILE_4x2",
412                    sizeof(pixFormatStr));
413             break;
414         case HAL_PIXEL_FORMAT_YCbCr_420_SP:
415             strlcpy(pixFormatStr, "YCbCr_420_SP", sizeof(pixFormatStr));
416             break;
417         case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
418             strlcpy(pixFormatStr, "YCrCb_420_SP_ADRENO", sizeof(pixFormatStr));
419             break;
420         case HAL_PIXEL_FORMAT_YCrCb_422_SP:
421             strlcpy(pixFormatStr, "YCrCb_422_SP", sizeof(pixFormatStr));
422             break;
423         case HAL_PIXEL_FORMAT_R_8:
424             strlcpy(pixFormatStr, "R_8", sizeof(pixFormatStr));
425             break;
426         case HAL_PIXEL_FORMAT_RG_88:
427             strlcpy(pixFormatStr, "RG_88", sizeof(pixFormatStr));
428             break;
429         case HAL_PIXEL_FORMAT_INTERLACE:
430             strlcpy(pixFormatStr, "INTERLACE", sizeof(pixFormatStr));
431             break;
432         case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
433             strlcpy(pixFormatStr, "YCbCr_420_SP_VENUS", sizeof(pixFormatStr));
434             break;
435         default:
436             size_t len = sizeof(pixFormatStr);
437             snprintf(pixFormatStr, len, "Unknown0x%X", format);
438             break;
439     }
440 }
441 
442 } // namespace qhwc
443 
444