void load_format(GraphType& g,
const std::string& path,
const std::string& format) {
line_parser_type<GraphType> line_parser;
if (path.length() == 0)
return;
if (format == "snap") {
line_parser = builtin_parsers::snap_parser<GraphType>;
load(g, path, line_parser);
} else if (format == "adj") {
line_parser = builtin_parsers::adj_parser<GraphType>;
load(g, path, line_parser);
} else if (format == "tsv") {
line_parser = builtin_parsers::tsv_parser<GraphType>;
load(g, path, line_parser);
} else if (format == "csv") {
line_parser = builtin_parsers::csv_parser<GraphType>;
load(g, path, line_parser);
} else if (format == "graphjrl") {
line_parser = builtin_parsers::graphjrl_parser<GraphType>;
load(g, path, line_parser);
// } else if (format == "bintsv4") {
// load_direct(path,&graph_type::load_bintsv4_from_stream);
} else if (format == "bin") {
load_binary(g, path);
} else {
logstream(LOG_ERROR)
<< "Unrecognized Format \"" << format << "\"!" << std::endl;
return;
}
} // end of load
void content_manager::load_file( u32 str_hash, void* data, type_name type)
{
if( type == type_name::geometry )
{
if( is_binary( str_hash ) )
{
load_binary( str_hash, data, type );
}
else
{
geometry_file geo_file( _filelist.find( str_hash )->second, geometry_file::wavefront, _content_pool );
geo_file.create_geometry_content( (geometry_content*)data );
}
return;
}
if( type == type_name::texture )
{
if( is_binary( str_hash ) )
{
load_binary( str_hash, data, type );
}
else
{
((texture_content*)data)->data = (crap::texture*)_content_pool->allocate( sizeof(crap::texture) );
crap::string256 path = DATA_PATH;
path += _filelist.find( str_hash )->second;
*((texture_content*)data)->data = crap::create_texture( path.cstring(), crap::tga );
}
return;
}
if( type == type_name::shader )
{
if( is_binary( str_hash ) )
{
load_binary( str_hash, data, type );
}
else
{
shader_file sdr_file( _filelist.find( str_hash )->second, _content_pool );
sdr_file.create_shader_content( (shader_content*)data );
}
return;
}
}
void serialize(input_archive & ar, std::basic_string<Char, CharTraits,
Allocator> & s, unsigned)
{
std::uint64_t size = 0;
ar >> size; //-V128
s.clear();
if (s.size() < size)
s.resize(size);
load_binary(ar, &s[0], size * sizeof(Char));
}
void load_bitwise(T & t, boost::mpl::true_)
{
BOOST_STATIC_ASSERT_MSG(!boost::is_abstract<T>::value,
"Can not bitwise serialize a class that is abstract");
if(disable_array_optimization())
{
serialize(*this, t, 0);
}
else
{
load_binary(&t, sizeof(t));
}
}
void serialize(input_archive & ar, std::basic_string<Char, CharTraits,
Allocator> & s, unsigned)
{
typedef std::basic_string<Char, CharTraits, Allocator> string_type;
typedef typename string_type::size_type size_type;
size_type size = 0;
ar >> size; //-V128
s.clear();
s.resize(size);
load_binary(ar, &s[0], size * sizeof(Char));
}
void load_integral_impl(boost::uint64_t & ul)
{
const std::size_t size = sizeof(boost::uint64_t);
char* cptr = reinterpret_cast<char *>(&ul);
load_binary(cptr, static_cast<std::size_t>(size));
#ifdef BOOST_BIG_ENDIAN
if (endian_little())
reverse_bytes(size, cptr);
#else
if (endian_big())
reverse_bytes(size, cptr);
#endif
}
void load_integral_impl(Promoted& l)
{
const std::size_t size = sizeof(Promoted);
char* cptr = reinterpret_cast<char *>(&l); //-V206
load_binary(cptr, static_cast<std::size_t>(size));
#ifdef BOOST_BIG_ENDIAN
if (endian_little())
reverse_bytes(size, cptr);
#else
if (endian_big())
reverse_bytes(size, cptr);
#endif
}
bool load_kernels(bool experimental)
{
/* verify if device was initialized */
if(!device_initialized) {
fprintf(stderr, "OpenCL: failed to initialize device.\n");
return false;
}
/* verify we have right opencl version */
if(!opencl_version_check())
return false;
/* md5 hash to detect changes */
string kernel_path = path_get("kernel");
string kernel_md5 = path_files_md5_hash(kernel_path);
string device_md5 = device_md5_hash();
/* try to use cache binary */
string clbin = string_printf("cycles_kernel_%s_%s.clbin", device_md5.c_str(), kernel_md5.c_str());;
clbin = path_user_get(path_join("cache", clbin));
if(path_exists(clbin)) {
/* if exists already, try use it */
if(!load_binary(kernel_path, clbin))
return false;
}
else {
/* compile kernel */
if(!compile_kernel(kernel_path, kernel_md5))
return false;
/* save binary for reuse */
save_binary(clbin);
}
/* find kernels */
ckPathTraceKernel = clCreateKernel(cpProgram, "kernel_ocl_path_trace", &ciErr);
if(opencl_error(ciErr))
return false;
ckFilmConvertKernel = clCreateKernel(cpProgram, "kernel_ocl_tonemap", &ciErr);
if(opencl_error(ciErr))
return false;
return true;
}
u32 load_file(const char *fn, u8 *buf, u32 bufsize)
{
FILE *f = fopen(fn, "r");
if (f == 0) {
return 0;
}
char s[100];
fgets(s, sizeof(s), f);
fclose(f);
u32 r = 0;
int n;
if (sscanf(s, ":%02x", &n) == 1 && strcspn(s, "\r\n") == 11+2*n) {
r = load_hex(fn, buf, bufsize);
if (r == 0) {
perror(fn);
exit(1);
}
} else {
r = load_binary(fn, buf, bufsize);
}
return r;
}
void load_impl(input_archive & ar, compute::vector<T, Allocator> & v,
std::true_type)
{
if(ar.disable_array_optimization())
{
load_impl(ar, v, std::false_type());
}
else
{
// bitwise load ...
typedef typename compute::vector<T, Allocator>::value_type
value_type;
typedef typename compute::vector<T, Allocator>::size_type
size_type;
size_type size;
ar >> size; //-V128
if(size == 0) return;
v.resize(size);
load_binary(ar, &v[0], v.size() * sizeof(value_type));
}
}
void load(bool & b)
{
load_binary(&b, sizeof(bool));
HPX_ASSERT(0 == static_cast<int>(b) || 1 == static_cast<int>(b));
}
void load(char & c)
{
load_binary(&c, sizeof(char));
}
void load(double & d)
{
load_binary(&d, sizeof(double));
}
void load(float & f)
{
load_binary(&f, sizeof(float));
}
void load(T & t){
load_binary(& t, sizeof(T));
}
// trap usage of invalid uninitialized boolean
void load(bool & t){
load_binary(& t, sizeof(t));
int i = t;
BOOST_ASSERT(0 == i || 1 == i);
(void)i; // warning suppression for release builds.
}
int fwengine(const unsigned char *_img, int size, void *ar)
{
unsigned char *img = (unsigned char*)_img;
unsigned int crc;
int i;
/* 14 is the minimal size of an empty image */
if( ! (*img) || (*img != 0xFF) || (size <14) )
{
syserr("Wrong image or no image\n");
return -1;
}
/* Check crc32 */
cp = img + size - 4;
*cp = ~(*cp) & 0xFF ; cp++;
*cp = ~(*cp) & 0xFF ; cp++;
*cp = ~(*cp) & 0xFF ; cp++;
*cp = ~(*cp) & 0xFF ;
crc = crc32( ~0, img, size );
if( crc )
{
syserr("Image CRC error\n");
return -1;
}
if( *(img+1) > VERSION )
{
syserr("Image version is newer than the driver\n");
return -1;
}
/* Basic checks complete, we can print greeting and FW_ID here if desired */
/* Get to the first opcode */
cp = img + 2; /* Skip magic and version */
offset = 2;
while( (offset < size) && (*cp) )
{
cp++; /* Skip build host name */
offset++;
}
cp += 6; /* Skip build date */
offset += 6;
while( (cp > img) && (cp < (img+size-4)) ) /* just an additional bounds check */
{
/* First, find out opcode class */
switch( (*cp & 0xF0) )
{
case RLoad :
ACC = getarg( );
break;
case Ror :
ACC |= getarg( );
break;
case Rand :
ACC &= getarg( );
break;
case Add :
ACC += getarg( );
break;
case Rstor :
regs[ *cp & 0xF ] = ACC;
cp++;
offset++;
break;
case Shift :
i = getarg( );
if(i < 0)
ACC >>= -i;
else
ACC <<= i;
break;
case Nneg :
if( *cp & 0xF )
regs[ *cp & 0xF ] = ~regs[ *cp & 0xF ];
else
ACC = -ACC;
cp++;
offset++;
break;
case Trr :
ACC = get_target_reg( getarg(), ar );
break;
case Trw :
write_target_reg( getarg(), ACC , ar );
break;
case Trx :
ACC = execute_on_target( getarg(), ACC, ar );
break;
case Exit :
if( *cp & 0xF ) /* abort with code */
return( regs[ *cp & 0xF ] );
else{ /* clean exit */
bmidone( ar );
return(0);
}
break;
case Cmp :
ACC -= getarg();
break;
case Ldprn :
if( ! (*cp & 0xF) ) /* register dump */
dumpregs();
else
{
int ret;
ret = load_binary(ACC, cp, ar);
if( ret < 0 )
return( -1 ); /* Error */
cp += ret;
offset += ret;
}
break;
case Jump :
if( !(*cp & 0xF) ||
((*cp == 0xE1) && (ACC)) ||
((*cp == 0xE2) && !(ACC)) )
offset = getoffset();
cp = img + offset;
break;
default:
syserr("Image format error\n");
break;
}
}
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
bool RendererVk::initGraphics(int w, int h, float SSScale, int MSAA)
{
bool bRes;
if(m_bValid)
return true;
m_bValid = true;
//--------------------------------------------------------------------------
// Create the Vulkan device
//
bRes = nvk.CreateDevice();
assert(bRes);
//--------------------------------------------------------------------------
// Get the OpenGL extension for merging VULKAN with OpenGL
//
#ifdef WIN32
//glGetVkInstanceProcAddrNV = (PFNGLGETVKINSTANCEPROCADDRNVPROC)GetProcAddress(hlib, "glGetVkInstanceProcAddrNV");
glWaitVkSemaphoreNV = (PFNGLWAITVKSEMAPHORENVPROC)NVPWindow::sysGetProcAddress("glWaitVkSemaphoreNV");
glSignalVkSemaphoreNV = (PFNGLSIGNALVKSEMAPHORENVPROC)NVPWindow::sysGetProcAddress("glSignalVkSemaphoreNV");
glSignalVkFenceNV = (PFNGLSIGNALVKFENCENVPROC)NVPWindow::sysGetProcAddress("glSignalVkFenceNV");
glDrawVkImageNV = (PFNGLDRAWVKIMAGENVPROC)NVPWindow::sysGetProcAddress("glDrawVkImageNV");
if(glDrawVkImageNV == NULL)
{
LOGE("couldn't find entry points to blit Vulkan to OpenGL back-buffer (glDrawVkImageNV...)");
nvk.DestroyDevice();
m_bValid = false;
return false;
}
#else //ellif (__linux__)
// TODO
#endif
VkSemaphoreCreateInfo semCreateInfo = { VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO };
m_semOpenGLReadDone = nvk.vkCreateSemaphore();
// Signal Semaphore by default to avoid being stuck
glSignalVkSemaphoreNV((GLuint64)m_semOpenGLReadDone);
m_semVKRenderingDone = nvk.vkCreateSemaphore();
//--------------------------------------------------------------------------
// Command pool for the main thread
//
VkCommandPoolCreateInfo cmdPoolInfo = { VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
cmdPoolInfo.queueFamilyIndex = 0;
cmdPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
CHECK(vkCreateCommandPool(nvk.m_device, &cmdPoolInfo, NULL, &m_cmdPool));
//--------------------------------------------------------------------------
// TODO
initTimers(nv_helpers::Profiler::START_TIMERS);
//--------------------------------------------------------------------------
// Load SpirV shaders
//
std::string spv_GLSL_fur_frag;
std::string spv_GLSL_fur_vert;
bRes = true;
if(!load_binary(std::string("GLSL/GLSL_fur_frag.spv"), spv_GLSL_fur_frag)) bRes = false;
if(!load_binary(std::string("GLSL/GLSL_fur_vert.spv"), spv_GLSL_fur_vert)) bRes = false;
if (bRes == false)
{
LOGE("Failed loading some SPV files\n");
nvk.DestroyDevice();
m_bValid = false;
return false;
}
//--------------------------------------------------------------------------
// Buffers for general UBOs
//
m_matrix.Sz = sizeof(vec4f)*4*2;
m_matrix.buffer = nvk.createAndFillBuffer(m_cmdPool, m_matrix.Sz, NULL, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, m_matrix.bufferMem);
m_matrix.bufferView = nvk.vkCreateBufferView(m_matrix.buffer, VK_FORMAT_UNDEFINED, m_matrix.Sz);
//--------------------------------------------------------------------------
// descriptor set
//
// descriptor layout for general things (projection matrix; view matrix...)
m_descriptorSetLayouts[DSET_GLOBAL] = nvk.vkCreateDescriptorSetLayout(
NVK::VkDescriptorSetLayoutCreateInfo(NVK::VkDescriptorSetLayoutBinding
(BINDING_MATRIX, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT) // BINDING_MATRIX
//(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT) // BINDING_LIGHT
) );
// descriptor layout for object level: buffers related to the object (objec-matrix; material colors...)
// This part will use the offsets to adjust buffer data
m_descriptorSetLayouts[DSET_OBJECT] = nvk.vkCreateDescriptorSetLayout(
NVK::VkDescriptorSetLayoutCreateInfo(NVK::VkDescriptorSetLayoutBinding
(BINDING_MATRIXOBJ, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT) // BINDING_MATRIXOBJ
(BINDING_MATERIAL , VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_FRAGMENT_BIT) // BINDING_MATERIAL
) );
//
// PipelineLayout
//
m_pipelineLayout = nvk.vkCreatePipelineLayout(m_descriptorSetLayouts, DSET_TOTALAMOUNT);
//--------------------------------------------------------------------------
// Init 'pipelines'
//
//
// what is needed to tell which states are dynamic
//
NVK::VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo(
NVK::VkDynamicState
(VK_DYNAMIC_STATE_VIEWPORT)
(VK_DYNAMIC_STATE_SCISSOR)
);
NVK::VkPipelineViewportStateCreateInfo vkPipelineViewportStateCreateInfo(
NVK::VkViewport(0.0f,0.0f,(float)w, (float)h,0.0f,1.0f),
NVK::VkRect2DArray(0.0f,0.0f,(float)w, (float)h)
);
NVK::VkPipelineRasterizationStateCreateInfo vkPipelineRasterStateCreateInfo(
VK_TRUE, //depthClipEnable
VK_FALSE, //rasterizerDiscardEnable
VK_POLYGON_MODE_FILL, //fillMode
VK_CULL_MODE_NONE, //cullMode
VK_FRONT_FACE_COUNTER_CLOCKWISE, //frontFace
VK_TRUE, //depthBiasEnable
0.0, //depthBias
0.0, //depthBiasClamp
0.0, //slopeScaledDepthBias
1.0 //lineWidth
);
NVK::VkPipelineColorBlendStateCreateInfo vkPipelineColorBlendStateCreateInfo(
VK_FALSE/*logicOpEnable*/,
VK_LOGIC_OP_NO_OP,
NVK::VkPipelineColorBlendAttachmentState(
VK_FALSE/*blendEnable*/,
VK_BLEND_FACTOR_ZERO /*srcBlendColor*/,
VK_BLEND_FACTOR_ZERO /*destBlendColor*/,
VK_BLEND_OP_ADD /*blendOpColor*/,
VK_BLEND_FACTOR_ZERO /*srcBlendAlpha*/,
VK_BLEND_FACTOR_ZERO /*destBlendAlpha*/,
VK_BLEND_OP_ADD /*blendOpAlpha*/,
VK_COLOR_COMPONENT_R_BIT|VK_COLOR_COMPONENT_G_BIT|VK_COLOR_COMPONENT_B_BIT|VK_COLOR_COMPONENT_A_BIT/*colorWriteMask*/),
NVK::Float4() //blendConst[4]
);
NVK::VkPipelineDepthStencilStateCreateInfo vkPipelineDepthStencilStateCreateInfo(
VK_TRUE, //depthTestEnable
VK_TRUE, //depthWriteEnable
VK_COMPARE_OP_LESS_OR_EQUAL, //depthCompareOp
VK_FALSE, //depthBoundsTestEnable
VK_FALSE, //stencilTestEnable
NVK::VkStencilOpState(), NVK::VkStencilOpState(), //front, back
0.0f, 1.0f //minDepthBounds, maxDepthBounds
);
::VkSampleMask sampleMask = 0xFFFF;
NVK::VkPipelineMultisampleStateCreateInfo vkPipelineMultisampleStateCreateInfo(
(VkSampleCountFlagBits)MSAA /*rasterSamples*/, VK_FALSE /*sampleShadingEnable*/, 1.0 /*minSampleShading*/, &sampleMask /*sampleMask*/, VK_FALSE, VK_FALSE);
//
// Fur gfx pipeline
//
m_pipelinefur = nvk.vkCreateGraphicsPipeline(NVK::VkGraphicsPipelineCreateInfo
(m_pipelineLayout,0)
(NVK::VkPipelineVertexInputStateCreateInfo(
NVK::VkVertexInputBindingDescription (0/*binding*/, sizeof(Vertex)/*stride*/, VK_VERTEX_INPUT_RATE_VERTEX),
NVK::VkVertexInputAttributeDescription (0/*location*/, 0/*binding*/, VK_FORMAT_R32G32B32_SFLOAT, 0) // pos
(1/*location*/, 0/*binding*/, VK_FORMAT_R32G32B32_SFLOAT, sizeof(vec3f)) // normal
(2/*location*/, 0/*binding*/, VK_FORMAT_R32G32B32A32_SFLOAT, 2*sizeof(vec3f)) // color
) )
(NVK::VkPipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_FALSE) )
(NVK::VkPipelineShaderStageCreateInfo(
VK_SHADER_STAGE_VERTEX_BIT, nvk.vkCreateShaderModule(spv_GLSL_fur_vert.c_str(), spv_GLSL_fur_vert.size()), "main") )
(vkPipelineViewportStateCreateInfo)
(vkPipelineRasterStateCreateInfo)
(vkPipelineMultisampleStateCreateInfo)
(NVK::VkPipelineShaderStageCreateInfo(
VK_SHADER_STAGE_FRAGMENT_BIT, nvk.vkCreateShaderModule(spv_GLSL_fur_frag.c_str(), spv_GLSL_fur_frag.size()), "main") )
(vkPipelineColorBlendStateCreateInfo)
(vkPipelineDepthStencilStateCreateInfo)
(dynamicStateCreateInfo)
);
//
// Create the buffer with these data
//
std::vector<Vertex> data;
buildFur(data);
m_nElmts = data.size();
GLuint vbofurSz = data.size() * sizeof(Vertex);
m_furBuffer.buffer = nvk.createAndFillBuffer(m_cmdPool, vbofurSz, &(data[0]), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, m_furBuffer.bufferMem);
//
// Descriptor Pool: size is 4 to have enough for global; object and ...
// TODO: try other VkDescriptorType
//
m_descPool = nvk.vkCreateDescriptorPool(NVK::VkDescriptorPoolCreateInfo(
3, NVK::VkDescriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3)
(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 3) )
);
//
// DescriptorSet allocation
// Here we allocate only the global descriptor set
// Objects will do their own allocation later
//
nvk.vkAllocateDescriptorSets(NVK::VkDescriptorSetAllocateInfo
(m_descPool, 1, m_descriptorSetLayouts + DSET_GLOBAL),
&m_descriptorSetGlobal);
//
// update the descriptorset used for Global
// later we will update the ones local to objects
//
NVK::VkDescriptorBufferInfo descBuffer = NVK::VkDescriptorBufferInfo(m_matrix.buffer, 0, m_matrix.Sz);
nvk.vkUpdateDescriptorSets(NVK::VkWriteDescriptorSet
(m_descriptorSetGlobal, BINDING_MATRIX, 0, descBuffer, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER)
);
//
// Create a Fence for the primary command-buffer
//
m_sceneFence[0] = nvk.vkCreateFence();
m_sceneFence[1] = nvk.vkCreateFence(VK_FENCE_CREATE_SIGNALED_BIT);
nvk.vkResetFences(2, m_sceneFence);
//
// initialize the super-sampled render-target. But at this stage we don't know the viewport size...
// TODO: put it somewhere else
//
downsamplingMode = NVFBOBoxVK::DS2;
m_nvFBOBox.Initialize(nvk, w, h, SSScale, MSAA);
return true;
}
static enum sh_css_err
init_binary_info(struct sh_css_binary_info *info, bool *binary_found)
{
unsigned int max_internal_width;
switch (info->id) {
case SH_CSS_BINARY_ID_COPY:
_init_binary_info(info, ISP_COPY_);
break;
case SH_CSS_BINARY_ID_VF_PP:
_init_binary_info(info, ISP_VF_PP_);
break;
case SH_CSS_BINARY_ID_CAPTURE_PP:
_init_binary_info(info, ISP_CAPTURE_PP_);
break;
case SH_CSS_BINARY_ID_PRE_ISP:
_init_binary_info(info, ISP_PRE_ISP_);
break;
case SH_CSS_BINARY_ID_GDC:
_init_binary_info(info, ISP_GDC_);
break;
case SH_CSS_BINARY_ID_POST_ISP:
_init_binary_info(info, ISP_POST_ISP_);
break;
#ifndef SYSTEM_hive_isp_css_2400_system
case SH_CSS_BINARY_ID_ANR:
_init_binary_info(info, ISP_ANR_);
#endif
break;
case SH_CSS_BINARY_ID_PREVIEW_DZ:
_init_binary_info(info, ISP_PREVIEW_DZ_);
break;
case SH_CSS_BINARY_ID_PREVIEW_DS:
_init_binary_info(info, ISP_PREVIEW_DS_);
break;
case SH_CSS_BINARY_ID_PRIMARY_SMALL:
_init_binary_info(info, ISP_PRIMARY_SMALL_);
break;
case SH_CSS_BINARY_ID_PRIMARY_DS:
_init_binary_info(info, ISP_PRIMARY_DS_);
break;
case SH_CSS_BINARY_ID_BAYER_DS:
_init_binary_info(info, ISP_BAYER_DS_);
break;
case SH_CSS_BINARY_ID_VIDEO_OFFLINE:
_init_binary_info(info, ISP_VIDEO_OFFLINE_);
break;
case SH_CSS_BINARY_ID_PRIMARY_VAR:
_init_binary_info(info, ISP_PRIMARY_VAR_);
break;
case SH_CSS_BINARY_ID_PRIMARY_8MP:
_init_binary_info(info, ISP_PRIMARY_8MP_);
break;
case SH_CSS_BINARY_ID_PRIMARY_14MP:
_init_binary_info(info, ISP_PRIMARY_14MP_);
break;
case SH_CSS_BINARY_ID_PRIMARY_16MP:
_init_binary_info(info, ISP_PRIMARY_16MP_);
break;
case SH_CSS_BINARY_ID_PRIMARY_REF:
_init_binary_info(info, ISP_PRIMARY_REF_);
break;
case SH_CSS_BINARY_ID_VIDEO_DZ:
_init_binary_info(info, ISP_VIDEO_DZ_);
break;
case SH_CSS_BINARY_ID_VIDEO_NODZ:
_init_binary_info(info, ISP_VIDEO_NODZ_);
break;
case SH_CSS_BINARY_ID_VIDEO_DS:
_init_binary_info(info, ISP_VIDEO_DS_);
break;
default:
return sh_css_err_invalid_arguments;
}
info->s3atbl_use_dmem = _S3ATBL_USE_DMEM(info->min_output_width !=
info->max_output_width);
/* The ISP uses the veceven module for output, on the host however
* we don't want to know about it. We treat preview output as regular
* output, not as viewfinder output. */
if (info->mode == SH_CSS_BINARY_MODE_PREVIEW)
info->enable_vf_veceven = false;
info->variable_vf_veceven = info->mode == SH_CSS_BINARY_MODE_COPY;
max_internal_width =
__ISP_INTERNAL_WIDTH(info->max_output_width,
info->max_dvs_envelope_width,
info->left_cropping,
info->mode,
info->c_subsampling,
info->output_num_chunks,
info->pipelining,
supports_output_format(info,
SH_CSS_FRAME_FORMAT_RGBA888));
info->max_input_width = _ISP_MAX_INPUT_WIDTH(max_internal_width,
info->enable_ds);
info->xmem_addr = NULL;
info->next = NULL;
return load_binary(info, binary_found);
}
