videocodec/securevideo/moorefield/LogDumpHelper.h - platform/hardware/intel/common/omx-components - Git at Google

 /*
 * Copyright (c) 2014 Intel Corporation.  All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

 #ifndef LOG_DUMP_HELPER_INCLUDED
 #define LOG_DUMP_HELPER_INCLUDED

 #ifndef LOG_TAG
 #error "Before including this file, must #define LOG_TAG and #include <utils/Log.h>"
 #endif

 #if LOG_NDEBUG == 0

 // We have dump routines for the structures defined in the following files:
 #include "VideoFrameInfo.h"
 #include "ProtectedDataBuffer.h"

 // The following helps to use these dump routines from command line unit tests:
 #ifdef ANDROID
 #define DUMP_EOL    ""
 #else
 #define LOGV    printf
 #define LOGE    printf
 #define DUMP_EOL    "\n"
 #endif // ANDROID

 #ifndef log_helper_min
 #define log_helper_min(a,b) ((a) < (b) ? (a) : (b))
 #endif // log_helper_min

 static inline void Copy4Bytes(void* dst, const void* src)
 {
     // Don't check input pointers for NULL: this is internal function,
     // and if you pass NULL to it, your code deserves to crash.

     uint8_t* bdst = (uint8_t*) dst ;
     const uint8_t* bsrc = (const uint8_t*) src ;

     *bdst++ = *bsrc++ ;
     *bdst++ = *bsrc++ ;
     *bdst++ = *bsrc++ ;
     *bdst = *bsrc ;
 }
 // End of Copy4Bytes()

 static void DumpBufferToString(char* str, uint32_t strSize, const uint8_t* start, uint32_t size)
 {
     if (str == NULL || strSize == 0 || start == NULL || size == 0)
     {
         LOGV("Error: invalid parameters to %s", __FUNCTION__) ;
         return ;
     }

     char* s = str ;
     char* send = str + strSize ;

     const uint8_t* byte = start ;
     const uint8_t* end = start + size ;

     while (byte < end && s < send)
     {
         s += snprintf(s, strSize - (s - str), "%02x ", *byte) ;
         ++byte ;
     }
 }
 // End of DumpBufferToString()

 static void DumpNaluDataBuffer(uint32_t nalu, const uint8_t* start, uint32_t size)
 {
     if (start == NULL || size == 0)
     {
         LOGV("NALU-dump: error: invalid parameters to %s", __FUNCTION__) ;
         return ;
     }

     const uint32_t STR_SIZE = 1024 ;
     char str[STR_SIZE] = {0} ;

     DumpBufferToString(str, STR_SIZE, start, size) ;

     LOGV("NALU-dump(nalu %u): data: %s" DUMP_EOL, nalu, str) ;
 }
 // End of DumpNaluDataBuffer()

 static void DumpBuffer(const char* prefix, const uint8_t* start, uint32_t size)
 {
     if (start == NULL || size == 0)
     {
         LOGV("Error: invalid parameters to %s", __FUNCTION__) ;
         return ;
     }

     if (prefix == NULL)
     {
         prefix = "" ;
     }

     const uint32_t STR_SIZE = 1024 ;
     char str[STR_SIZE] = {0} ;

     DumpBufferToString(str, STR_SIZE, start, size) ;

     LOGV("%s: ptr=%p, size=%u, data=%s" DUMP_EOL, prefix, start, size, str) ;
 }
 // End of DumpBuffer()

 static void DumpNaluHeaderBuffer(const uint8_t* const start, uint32_t size)
 {
     if (start == NULL || size == 0)
     {
         LOGV("Error: invalid parameters to %s", __FUNCTION__) ;
         return ;
     }

     const uint8_t* current = start ;

     uint32_t numNALUs = 0 ;
     Copy4Bytes(&numNALUs, current) ;
     current += sizeof(numNALUs) ;

     LOGV("NALU-dump: num NALUs = %u\n", numNALUs) ;

     if (numNALUs > MAX_NALUS_IN_FRAME)
     {
         LOGE("NALU-dump: ERROR, num NALUs is too big (%u)" DUMP_EOL, numNALUs) ;
     }

     for (uint32_t nalu = 0; nalu < numNALUs; ++nalu)
     {
         uint32_t imr_offset = 0 ;
         Copy4Bytes(&imr_offset, current) ;
         current += sizeof(imr_offset) ;

         uint32_t nalu_size = 0 ;
         Copy4Bytes(&nalu_size, current) ;
         current += sizeof(nalu_size) ;

         uint32_t data_size = 0 ;
         Copy4Bytes(&data_size, current) ;
         current += sizeof(data_size) ;

         LOGV("NALU-dump(nalu %u): imr_offset = %u, nalu_size = %u, data_size = %u" DUMP_EOL,
             nalu, imr_offset, nalu_size, data_size) ;

         DumpNaluDataBuffer(nalu, current, data_size) ;

         // Skip past the data
         current += data_size ;
     }
     // End of for
 }
 // End of DumpNaluHeaderBuffer()

 static const char* DrmSchemeToString(uint32_t drmScheme)
 {
     switch(drmScheme)
     {
         case DRM_SCHEME_NONE:
             return "None" ;

         case DRM_SCHEME_WV_CLASSIC:
             return "WV Classic" ;

         case DRM_SCHEME_WV_MODULAR:
             return "WV Modular" ;

 #ifdef DRM_SCHEME_MCAST_SINK
         case DRM_SCHEME_MCAST_SINK:
             return "MCast Sink" ;
 #endif

 #ifdef DRM_SCHEME_PLAYREADY_ASF
         case DRM_SCHEME_PLAYREADY_ASF:
             return "PlayReady/ASF" ;
 #endif

         default:
             return "unknown" ;
     }
 }
 // End of DrmSchemeToString()

 static void DumpBuffer2(const char* prefix, const uint8_t* start, uint32_t size)
 {
     if (start == NULL || size == 0)
     {
         LOGV("Error: invalid parameters to %s", __FUNCTION__) ;
         return ;
     }

     if (prefix == NULL)
     {
         prefix = "" ;
     }

     const uint32_t STR_SIZE = 1024 ;
     char str[STR_SIZE] = {0} ;

     DumpBufferToString(str, STR_SIZE, start, size) ;

     LOGV("%s%s" DUMP_EOL, prefix, str) ;
 }
 // End of DumpBuffer2()

 static void DumpProtectedDataBuffer(const char* prefix, ProtectedDataBuffer* buf)
 {
     if (buf == NULL)
     {
         LOGV("Error: invalid parameters to %s", __FUNCTION__) ;
         return ;
     }

     if (prefix == NULL) { prefix = "" ; }

     const uint32_t MAX_BUFFER_DUMP_LENGTH = 32 ;

     if (buf->magic != PROTECTED_DATA_BUFFER_MAGIC)
     {
         const uint8_t* p = (uint8_t*) &buf->magic ;
         LOGV("%sWrong magic: %02x %02x %02x %02x" DUMP_EOL, prefix, p[0], p[1], p[2], p[3]) ;
         return ;
     }

     LOGV("%smagic: ok, drmScheme: %u (%s), clear: %u, size: %u, num PES: %u" DUMP_EOL, prefix,
         buf->drmScheme, DrmSchemeToString(buf->drmScheme), buf->clear, buf->size, buf->numPesBuffers) ;

     if (buf->numPesBuffers == 0)
     {
         uint32_t dumpLength = log_helper_min(buf->size, MAX_BUFFER_DUMP_LENGTH) ;
         DumpBuffer2("data: ", buf->data, dumpLength) ;
     }
     else
     {
         for (uint32_t i = 0; i < buf->numPesBuffers; ++i)
         {
             const uint32_t STR_SIZE = 1024 ;
             char str[STR_SIZE] = {0} ;

             uint32_t dumpLength = log_helper_min(buf->pesBuffers[i].pesSize, MAX_BUFFER_DUMP_LENGTH) ;

             DumpBufferToString(str, STR_SIZE,
                 buf->data + buf->pesBuffers[i].pesDataOffset, dumpLength) ;

             LOGV("PES %u: streamCounter: %u, inputCounter: %llu, offset: %u, size: %u, PES data: %s" DUMP_EOL,
                 i, buf->pesBuffers[i].streamCounter, buf->pesBuffers[i].inputCounter,
                 buf->pesBuffers[i].pesDataOffset, buf->pesBuffers[i].pesSize, str) ;
         }
     }
 }
 // End of DumpProtectedDataBuffer

 static void DumpVideoFrameInfo(frame_info_t* fInfo)
 {
     if (fInfo == NULL)
     {
         LOGV("Error: invalid parameters to %s", __FUNCTION__) ;
         return ;
     }

     LOGV("frame_info_t: data = %p, size = %u, num_nalus = %u", fInfo->data, fInfo->size, fInfo->num_nalus) ;

     for (uint32_t i = 0; i < fInfo->num_nalus; ++i)
     {
         LOGV("nalu_info_t: type = %#x, offset = %u (%#x), data = %p, length = %u",
             fInfo->nalus[i].type, fInfo->nalus[i].offset, fInfo->nalus[i].offset,
             fInfo->nalus[i].data, fInfo->nalus[i].length) ;

         if (fInfo->nalus[i].data != NULL && fInfo->nalus[i].length > 0)
         {
             DumpBuffer2("nalu_info_t::data: ", fInfo->nalus[i].data, fInfo->nalus[i].length) ;
         }
     }
 }
 // End of DumpVideoFrameInfo()

 #else

 // Avoid #ifdef around the dump code

 #define DumpBuffer(...)
 #define DumpBuffer2(...)
 #define DumpNaluHeaderBuffer(...)
 #define DumpProtectedDataBuffer(...)
 #define DumpVideoFrameInfo(...)

 #define DUMP_EOL

 #endif // LOG_NDEBUG == 0

 #endif // LOG_DUMP_HELPER_INCLUDED
	/*
	* Copyright (c) 2014 Intel Corporation. All rights reserved.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifndef LOG_DUMP_HELPER_INCLUDED
	#define LOG_DUMP_HELPER_INCLUDED

	#ifndef LOG_TAG
	#error "Before including this file, must #define LOG_TAG and #include <utils/Log.h>"
	#endif

	#if LOG_NDEBUG == 0

	// We have dump routines for the structures defined in the following files:
	#include "VideoFrameInfo.h"
	#include "ProtectedDataBuffer.h"

	// The following helps to use these dump routines from command line unit tests:
	#ifdef ANDROID
	#define DUMP_EOL ""
	#else
	#define LOGV printf
	#define LOGE printf
	#define DUMP_EOL "\n"
	#endif // ANDROID

	#ifndef log_helper_min
	#define log_helper_min(a,b) ((a) < (b) ? (a) : (b))
	#endif // log_helper_min

	static inline void Copy4Bytes(void* dst, const void* src)
	{
	// Don't check input pointers for NULL: this is internal function,
	// and if you pass NULL to it, your code deserves to crash.

	uint8_t* bdst = (uint8_t*) dst ;
	const uint8_t* bsrc = (const uint8_t*) src ;

	bdst++ = bsrc++ ;
	bdst++ = bsrc++ ;
	bdst++ = bsrc++ ;
	bdst = bsrc ;
	}
	// End of Copy4Bytes()

	static void DumpBufferToString(char* str, uint32_t strSize, const uint8_t* start, uint32_t size)
	{
	if (str == NULL \|\| strSize == 0 \|\| start == NULL \|\| size == 0)
	{
	LOGV("Error: invalid parameters to %s", __FUNCTION__) ;
	return ;
	}

	char* s = str ;
	char* send = str + strSize ;

	const uint8_t* byte = start ;
	const uint8_t* end = start + size ;

	while (byte < end && s < send)
	{
	s += snprintf(s, strSize - (s - str), "%02x ", *byte) ;
	++byte ;
	}
	}
	// End of DumpBufferToString()

	static void DumpNaluDataBuffer(uint32_t nalu, const uint8_t* start, uint32_t size)
	{
	if (start == NULL \|\| size == 0)
	{
	LOGV("NALU-dump: error: invalid parameters to %s", __FUNCTION__) ;
	return ;
	}

	const uint32_t STR_SIZE = 1024 ;
	char str[STR_SIZE] = {0} ;

	DumpBufferToString(str, STR_SIZE, start, size) ;

	LOGV("NALU-dump(nalu %u): data: %s" DUMP_EOL, nalu, str) ;
	}
	// End of DumpNaluDataBuffer()

	static void DumpBuffer(const char* prefix, const uint8_t* start, uint32_t size)
	{
	if (start == NULL \|\| size == 0)
	{
	LOGV("Error: invalid parameters to %s", __FUNCTION__) ;
	return ;
	}

	if (prefix == NULL)
	{
	prefix = "" ;
	}

	const uint32_t STR_SIZE = 1024 ;
	char str[STR_SIZE] = {0} ;

	DumpBufferToString(str, STR_SIZE, start, size) ;

	LOGV("%s: ptr=%p, size=%u, data=%s" DUMP_EOL, prefix, start, size, str) ;
	}
	// End of DumpBuffer()

	static void DumpNaluHeaderBuffer(const uint8_t* const start, uint32_t size)
	{
	if (start == NULL \|\| size == 0)
	{
	LOGV("Error: invalid parameters to %s", __FUNCTION__) ;
	return ;
	}

	const uint8_t* current = start ;

	uint32_t numNALUs = 0 ;
	Copy4Bytes(&numNALUs, current) ;
	current += sizeof(numNALUs) ;

	LOGV("NALU-dump: num NALUs = %u\n", numNALUs) ;

	if (numNALUs > MAX_NALUS_IN_FRAME)
	{
	LOGE("NALU-dump: ERROR, num NALUs is too big (%u)" DUMP_EOL, numNALUs) ;
	}

	for (uint32_t nalu = 0; nalu < numNALUs; ++nalu)
	{
	uint32_t imr_offset = 0 ;
	Copy4Bytes(&imr_offset, current) ;
	current += sizeof(imr_offset) ;

	uint32_t nalu_size = 0 ;
	Copy4Bytes(&nalu_size, current) ;
	current += sizeof(nalu_size) ;

	uint32_t data_size = 0 ;
	Copy4Bytes(&data_size, current) ;
	current += sizeof(data_size) ;

	LOGV("NALU-dump(nalu %u): imr_offset = %u, nalu_size = %u, data_size = %u" DUMP_EOL,
	nalu, imr_offset, nalu_size, data_size) ;

	DumpNaluDataBuffer(nalu, current, data_size) ;

	// Skip past the data
	current += data_size ;
	}
	// End of for
	}
	// End of DumpNaluHeaderBuffer()

	static const char* DrmSchemeToString(uint32_t drmScheme)
	{
	switch(drmScheme)
	{
	case DRM_SCHEME_NONE:
	return "None" ;

	case DRM_SCHEME_WV_CLASSIC:
	return "WV Classic" ;

	case DRM_SCHEME_WV_MODULAR:
	return "WV Modular" ;

	#ifdef DRM_SCHEME_MCAST_SINK
	case DRM_SCHEME_MCAST_SINK:
	return "MCast Sink" ;
	#endif

	#ifdef DRM_SCHEME_PLAYREADY_ASF
	case DRM_SCHEME_PLAYREADY_ASF:
	return "PlayReady/ASF" ;
	#endif

	default:
	return "unknown" ;
	}
	}
	// End of DrmSchemeToString()

	static void DumpBuffer2(const char* prefix, const uint8_t* start, uint32_t size)
	{
	if (start == NULL \|\| size == 0)
	{
	LOGV("Error: invalid parameters to %s", __FUNCTION__) ;
	return ;
	}

	if (prefix == NULL)
	{
	prefix = "" ;
	}

	const uint32_t STR_SIZE = 1024 ;
	char str[STR_SIZE] = {0} ;

	DumpBufferToString(str, STR_SIZE, start, size) ;

	LOGV("%s%s" DUMP_EOL, prefix, str) ;
	}
	// End of DumpBuffer2()

	static void DumpProtectedDataBuffer(const char* prefix, ProtectedDataBuffer* buf)
	{
	if (buf == NULL)
	{
	LOGV("Error: invalid parameters to %s", __FUNCTION__) ;
	return ;
	}

	if (prefix == NULL) { prefix = "" ; }

	const uint32_t MAX_BUFFER_DUMP_LENGTH = 32 ;

	if (buf->magic != PROTECTED_DATA_BUFFER_MAGIC)
	{
	const uint8_t* p = (uint8_t*) &buf->magic ;
	LOGV("%sWrong magic: %02x %02x %02x %02x" DUMP_EOL, prefix, p[0], p[1], p[2], p[3]) ;
	return ;
	}

	LOGV("%smagic: ok, drmScheme: %u (%s), clear: %u, size: %u, num PES: %u" DUMP_EOL, prefix,
	buf->drmScheme, DrmSchemeToString(buf->drmScheme), buf->clear, buf->size, buf->numPesBuffers) ;

	if (buf->numPesBuffers == 0)
	{
	uint32_t dumpLength = log_helper_min(buf->size, MAX_BUFFER_DUMP_LENGTH) ;
	DumpBuffer2("data: ", buf->data, dumpLength) ;
	}
	else
	{
	for (uint32_t i = 0; i < buf->numPesBuffers; ++i)
	{
	const uint32_t STR_SIZE = 1024 ;
	char str[STR_SIZE] = {0} ;

	uint32_t dumpLength = log_helper_min(buf->pesBuffers[i].pesSize, MAX_BUFFER_DUMP_LENGTH) ;

	DumpBufferToString(str, STR_SIZE,
	buf->data + buf->pesBuffers[i].pesDataOffset, dumpLength) ;

	LOGV("PES %u: streamCounter: %u, inputCounter: %llu, offset: %u, size: %u, PES data: %s" DUMP_EOL,
	i, buf->pesBuffers[i].streamCounter, buf->pesBuffers[i].inputCounter,
	buf->pesBuffers[i].pesDataOffset, buf->pesBuffers[i].pesSize, str) ;
	}
	}
	}
	// End of DumpProtectedDataBuffer

	static void DumpVideoFrameInfo(frame_info_t* fInfo)
	{
	if (fInfo == NULL)
	{
	LOGV("Error: invalid parameters to %s", __FUNCTION__) ;
	return ;
	}

	LOGV("frame_info_t: data = %p, size = %u, num_nalus = %u", fInfo->data, fInfo->size, fInfo->num_nalus) ;

	for (uint32_t i = 0; i < fInfo->num_nalus; ++i)
	{
	LOGV("nalu_info_t: type = %#x, offset = %u (%#x), data = %p, length = %u",
	fInfo->nalus[i].type, fInfo->nalus[i].offset, fInfo->nalus[i].offset,
	fInfo->nalus[i].data, fInfo->nalus[i].length) ;

	if (fInfo->nalus[i].data != NULL && fInfo->nalus[i].length > 0)
	{
	DumpBuffer2("nalu_info_t::data: ", fInfo->nalus[i].data, fInfo->nalus[i].length) ;
	}
	}
	}
	// End of DumpVideoFrameInfo()

	#else

	// Avoid #ifdef around the dump code

	#define DumpBuffer(...)
	#define DumpBuffer2(...)
	#define DumpNaluHeaderBuffer(...)
	#define DumpProtectedDataBuffer(...)
	#define DumpVideoFrameInfo(...)

	#define DUMP_EOL

	#endif // LOG_NDEBUG == 0

	#endif // LOG_DUMP_HELPER_INCLUDED