{

if(fmt.compByteWidth == 8)

{

// we just downcast

uint64_t *u64 = (uint64_t *)data;

int64_t *i64 = (int64_t *)data;

if(fmt.compType == CompType::Double || fmt.compType == CompType::Float)

{

return float(*(double *)u64);

}

else if(fmt.compType == CompType::UInt || fmt.compType == CompType::UScaled)

{

return float(*u64);

}

else if(fmt.compType == CompType::SInt || fmt.compType == CompType::SScaled)

{

return float(*i64);

}

}

else if(fmt.compByteWidth == 4)

{

uint32_t *u32 = (uint32_t *)data;

int32_t *i32 = (int32_t *)data;

if(fmt.compType == CompType::Float)

{

return *(float *)u32;

}

else if(fmt.compType == CompType::UInt || fmt.compType == CompType::UScaled)

{

return float(*u32);

}

else if(fmt.compType == CompType::SInt || fmt.compType == CompType::SScaled)

{

return float(*i32);

}

}

else if(fmt.compByteWidth == 3 && fmt.compType == CompType::Depth)

{

// 24-bit depth is a weird edge case we need to assemble it by hand

uint8_t *u8 = (uint8_t *)data;

uint32_t depth = 0;

depth |= uint32_t(u8[1]);

depth |= uint32_t(u8[2]) << 8;

depth |= uint32_t(u8[3]) << 16;

return float(depth) / float(16777215.0f);

}

else if(fmt.compByteWidth == 2)

{

uint16_t *u16 = (uint16_t *)data;

int16_t *i16 = (int16_t *)data;

if(fmt.compType == CompType::Float)

{

return ConvertFromHalf(*u16);

}

else if(fmt.compType == CompType::UInt || fmt.compType == CompType::UScaled)

{

return float(*u16);

}

else if(fmt.compType == CompType::SInt || fmt.compType == CompType::SScaled)

{

return float(*i16);

}

// 16-bit depth is UNORM

else if(fmt.compType == CompType::UNorm || fmt.compType == CompType::Depth)

{

return float(*u16) / 65535.0f;

}

else if(fmt.compType == CompType::SNorm)

{

float f = -1.0f;

if(*i16 == -32768)

f = -1.0f;

else

f = ((float)*i16) / 32767.0f;

return f;

}

}

else if(fmt.compByteWidth == 1)

{

uint8_t *u8 = (uint8_t *)data;

int8_t *i8 = (int8_t *)data;

if(fmt.compType == CompType::UInt || fmt.compType == CompType::UScaled)

{

return float(*u8);

}

else if(fmt.compType == CompType::SInt || fmt.compType == CompType::SScaled)

{

return float(*i8);

}

else if(fmt.compType == CompType::UNorm)

{

if(fmt.srgbCorrected)

return SRGB8_lookuptable[*u8];

else

return float(*u8) / 255.0f;

}

else if(fmt.compType == CompType::SNorm)

{

float f = -1.0f;

if(*i8 == -128)

f = -1.0f;

else

f = ((float)*i8) / 127.0f;

return f;

}

}

RDCERR("Unexpected format to convert from");

return 0.0f;

{

m_pDevice = NULL;

m_EventID = 100000;

{

if(eventID != m_EventID || force)

{

m_EventID = eventID;

m_pDevice->ReplayLog(eventID, eReplay_WithoutDraw);

for(size_t i = 0; i < m_Outputs.size(); i++)

m_Outputs[i]->SetFrameEvent(eventID);

m_pDevice->ReplayLog(eventID, eReplay_OnlyDraw);

FetchPipelineState();

}

{

vector<GPUCounter> counterArray;

counterArray.reserve(counters.count);

for(int32_t i = 0; i < counters.count; i++)

counterArray.push_back(counters[i]);

return m_pDevice->FetchCounters(counterArray);

{

CounterDescription ret;

m_pDevice->DescribeCounter(counterID, ret);

return ret;

{

if(m_Buffers.empty())

{

vector<ResourceId> ids = m_pDevice->GetBuffers();

m_Buffers.resize(ids.size());

for(size_t i = 0; i < ids.size(); i++)

m_Buffers[i] = m_pDevice->GetBuffer(ids[i]);

}

return m_Buffers;

{

if(m_Textures.empty())

{

vector<ResourceId> ids = m_pDevice->GetTextures();

m_Textures.resize(ids.size());

for(size_t i = 0; i < ids.size(); i++)

m_Textures[i] = m_pDevice->GetTexture(ids[i]);

}

return m_Textures;

{

rdctype::array<rdctype::str> ret;

if(callstack.empty())

return ret;

Callstack::StackResolver *resolv = m_pDevice->GetCallstackResolver();

if(resolv == NULL)

return ret;

create_array_uninit(ret, (size_t)callstack.count);

for(int32_t i = 0; i < callstack.count; i++)

{

Callstack::AddressDetails info = resolv->GetAddr(callstack[i]);

ret[i] = info.formattedString();

}

return ret;

{

DrawcallDescription *draw = GetDrawcallByEID(m_EventID);

MeshFormat ret;

RDCEraseEl(ret);

if(draw == NULL || !(draw->flags & DrawFlags::Drawcall))

return MeshFormat();

instID = RDCMIN(instID, draw->numInstances - 1);

return m_pDevice->GetPostVSBuffers(draw->eventID, instID, stage);

{

rdctype::array<byte> ret;

if(buff == ResourceId())

return ret;

ResourceId liveId = m_pDevice->GetLiveID(buff);

if(liveId == ResourceId())

{

RDCERR("Couldn't get Live ID for %llu getting buffer data", buff);

return ret;

}

vector<byte> retData;

m_pDevice->GetBufferData(liveId, offset, len, retData);

create_array_init(ret, retData.size(), !retData.empty() ? &retData[0] : NULL);

return ret;

{

rdctype::array<byte> ret;

ResourceId liveId = m_pDevice->GetLiveID(tex);

if(liveId == ResourceId())

{

RDCERR("Couldn't get Live ID for %llu getting texture data", tex);

return ret;

}

size_t sz = 0;

byte *bytes = m_pDevice->GetTextureData(liveId, arrayIdx, mip, GetTextureDataParams(), sz);

if(sz == 0 || bytes == NULL)

create_array_uninit(ret, 0);

else

create_array_init(ret, sz, bytes);

SAFE_DELETE_ARRAY(bytes);

return ret;

{

TextureSave sd = saveData; // mutable copy

ResourceId liveid = m_pDevice->GetLiveID(sd.id);

TextureDescription td = m_pDevice->GetTexture(liveid);

bool success = false;

// clamp sample/mip/slice indices

if(td.msSamp == 1)

{

sd.sample.sampleIndex = 0;

sd.sample.mapToArray = false;

}

else

{

if(sd.sample.sampleIndex != ~0U)

sd.sample.sampleIndex = RDCCLAMP(sd.sample.sampleIndex, 0U, td.msSamp);

}

// don't support cube cruciform for non cubemaps, or

// cubemap arrays

if(!td.cubemap || td.arraysize != 6 || td.msSamp != 1)

sd.slice.cubeCruciform = false;

if(sd.mip != -1)

sd.mip = RDCCLAMP(sd.mip, 0, (int32_t)td.mips);

if(sd.slice.sliceIndex != -1)

sd.slice.sliceIndex = RDCCLAMP(sd.slice.sliceIndex, 0, int32_t(td.arraysize * td.depth));

if(td.arraysize * td.depth * td.msSamp == 1)

{

sd.slice.sliceIndex = 0;

sd.slice.slicesAsGrid = false;

}

// can't extract a channel that's not in the source texture

if(sd.channelExtract >= 0 && (uint32_t)sd.channelExtract >= td.format.compCount)

sd.channelExtract = -1;

sd.slice.sliceGridWidth = RDCMAX(sd.slice.sliceGridWidth, 1);

// store sample count so we know how many 'slices' is one real slice

// multisampled textures cannot have mips, subresource layout is same as would be for mips:

// [slice0 sample0], [slice0 sample1], [slice1 sample0], [slice1 sample1]

uint32_t sampleCount = td.msSamp;

bool multisampled = td.msSamp > 1;

bool resolveSamples = (sd.sample.sampleIndex == ~0U);

if(resolveSamples)

{

td.msSamp = 1;

sd.sample.mapToArray = false;

sd.sample.sampleIndex = 0;

}

// treat any multisampled texture as if it were an array

// of <sample count> dimension (on top of potential existing array

// dimension). GetTextureData() uses the same convention.

if(td.msSamp > 1)

{

td.arraysize *= td.msSamp;

td.msSamp = 1;

}

if(sd.destType != FileType::DDS && sd.sample.mapToArray && !sd.slice.slicesAsGrid &&

sd.slice.sliceIndex == -1)

{

sd.sample.mapToArray = false;

sd.sample.sampleIndex = 0;

}

// only DDS supports writing multiple mips, fall back to mip 0 if 'all mips' was specified

if(sd.destType != FileType::DDS && sd.mip == -1)

sd.mip = 0;

// only DDS supports writing multiple slices, fall back to slice 0 if 'all slices' was specified

if(sd.destType != FileType::DDS && sd.slice.sliceIndex == -1 && !sd.slice.slicesAsGrid &&

!sd.slice.cubeCruciform)

sd.slice.sliceIndex = 0;

// fetch source data subresources (typically only one, possibly more

// if we're writing to DDS (so writing multiple mips/slices) or resolving

// down a multisampled texture for writing as a single 'image' elsewhere)

uint32_t sliceOffset = 0;

uint32_t sliceStride = 1;

uint32_t numSlices = td.arraysize * td.depth;

uint32_t mipOffset = 0;

uint32_t numMips = td.mips;

bool singleSlice = (sd.slice.sliceIndex != -1);

// set which slices/mips we need

if(multisampled)

{

bool singleSample = !sd.sample.mapToArray;

// multisampled images have no mips

mipOffset = 0;

numMips = 1;

if(singleSlice)

{

if(singleSample)

{

// we want a specific sample in a specific real slice

sliceOffset = sd.slice.sliceIndex * sampleCount + sd.sample.sampleIndex;

numSlices = 1;

}

else

{

// we want all the samples (now mapped to slices) in a specific real slice

sliceOffset = sd.slice.sliceIndex;

numSlices = sampleCount;

}

}

else

{

if(singleSample)

{

// we want one sample in every slice, so we have to set the stride to sampleCount

// to skip every other sample (mapped to slices), starting from the sample we want

// in the first real slice

sliceOffset = sd.sample.sampleIndex;

sliceStride = sampleCount;

numSlices = RDCMAX(1U, td.arraysize / sampleCount);

}

else

{

// we want all slices, all samples

sliceOffset = 0;

numSlices = td.arraysize;

}

}

}

else

{

if(singleSlice)

{

numSlices = 1;

sliceOffset = sd.slice.sliceIndex;

}

// otherwise take all slices, as by default

if(sd.mip != -1)

{

mipOffset = sd.mip;

numMips = 1;

}

// otherwise take all mips, as by default

}

vector<byte *> subdata;

bool downcast = false;

// don't support slice mappings for DDS - it supports slices natively

if(sd.destType == FileType::DDS)

{

sd.slice.cubeCruciform = false;

sd.slice.slicesAsGrid = false;

}

// force downcast to be able to do grid mappings

if(sd.slice.cubeCruciform || sd.slice.slicesAsGrid)

downcast = true;

// we don't support any file formats that handle these block compression formats

if(td.format.specialFormat == SpecialFormat::ETC2 ||

td.format.specialFormat == SpecialFormat::EAC || td.format.specialFormat == SpecialFormat::ASTC)

downcast = true;

// for DDS don't downcast, for non-HDR always downcast if we're not already RGBA8 unorm

// for HDR&EXR we can convert from most regular types as well as 10.10.10.2 and 11.11.10

if((sd.destType != FileType::DDS && sd.destType != FileType::HDR && sd.destType != FileType::EXR &&

(td.format.compByteWidth != 1 || td.format.compCount != 4 ||

td.format.compType != CompType::UNorm || td.format.bgraOrder)) ||

downcast || (sd.destType != FileType::DDS && td.format.special &&

td.format.specialFormat != SpecialFormat::R10G10B10A2 &&

td.format.specialFormat != SpecialFormat::R11G11B10))

{

downcast = true;

td.format.compByteWidth = 1;

td.format.compCount = 4;

td.format.compType = CompType::UNorm;

td.format.special = false;

td.format.specialFormat = SpecialFormat::Unknown;

}

uint32_t rowPitch = 0;

uint32_t slicePitch = 0;

bool blockformat = false;

int blockSize = 0;

uint32_t bytesPerPixel = 1;

td.width = RDCMAX(1U, td.width >> mipOffset);

td.height = RDCMAX(1U, td.height >> mipOffset);

td.depth = RDCMAX(1U, td.depth >> mipOffset);

if(td.format.specialFormat == SpecialFormat::BC1 ||

td.format.specialFormat == SpecialFormat::BC2 || td.format.specialFormat == SpecialFormat::BC3 ||

td.format.specialFormat == SpecialFormat::BC4 || td.format.specialFormat == SpecialFormat::BC5 ||

td.format.specialFormat == SpecialFormat::BC6 || td.format.specialFormat == SpecialFormat::BC7)

{

blockSize = (td.format.specialFormat == SpecialFormat::BC1 ||

td.format.specialFormat == SpecialFormat::BC4)

? 8

: 16;

rowPitch = RDCMAX(1U, ((td.width + 3) / 4)) * blockSize;

slicePitch = rowPitch * RDCMAX(1U, td.height / 4);

blockformat = true;

}

else

{

switch(td.format.specialFormat)

{

case SpecialFormat::S8: bytesPerPixel = 1; break;

case SpecialFormat::R10G10B10A2:

case SpecialFormat::R9G9B9E5:

case SpecialFormat::R11G11B10:

case SpecialFormat::D24S8: bytesPerPixel = 4; break;

case SpecialFormat::R5G6B5:

case SpecialFormat::R5G5B5A1:

case SpecialFormat::R4G4B4A4: bytesPerPixel = 2; break;

case SpecialFormat::D32S8: bytesPerPixel = 8; break;

case SpecialFormat::D16S8:

case SpecialFormat::YUV:

case SpecialFormat::R4G4:

RDCERR("Unsupported file format %u", td.format.specialFormat);

return false;

default: bytesPerPixel = td.format.compCount * td.format.compByteWidth;

}

rowPitch = td.width * bytesPerPixel;

slicePitch = rowPitch * td.height;

}

// loop over fetching subresources

for(uint32_t s = 0; s < numSlices; s++)

{

uint32_t slice = s * sliceStride + sliceOffset;

for(uint32_t m = 0; m < numMips; m++)

{

uint32_t mip = m + mipOffset;

GetTextureDataParams params;

params.forDiskSave = true;

params.typeHint = sd.typeHint;

params.resolve = resolveSamples;

params.remap = downcast ? eRemap_RGBA8 : eRemap_None;

params.blackPoint = sd.comp.blackPoint;

params.whitePoint = sd.comp.whitePoint;

size_t datasize = 0;

byte *bytes = m_pDevice->GetTextureData(liveid, slice, mip, params, datasize);

if(bytes == NULL)

{

RDCERR("Couldn't get bytes for mip %u, slice %u", mip, slice);

for(size_t i = 0; i < subdata.size(); i++)

delete[] subdata[i];

return false;

}

if(td.depth == 1)

{

subdata.push_back(bytes);

continue;

}

uint32_t mipSlicePitch = slicePitch;

uint32_t w = RDCMAX(1U, td.width >> m);

uint32_t h = RDCMAX(1U, td.height >> m);

uint32_t d = RDCMAX(1U, td.depth >> m);

if(blockformat)

{

mipSlicePitch = RDCMAX(1U, ((w + 3) / 4)) * blockSize * RDCMAX(1U, h / 4);

}

else

{

mipSlicePitch = w * bytesPerPixel * h;

}

// we don't support slice ranges, only all-or-nothing

// we're also not dealing with multisampled slices if

// depth > 1. So if we only want one slice out of a 3D texture

// then make sure we get it

if(numSlices == 1)

{

byte *depthslice = new byte[mipSlicePitch];

byte *b = bytes + mipSlicePitch * sliceOffset;

memcpy(depthslice, b, slicePitch);

subdata.push_back(depthslice);

delete[] bytes;

continue;

}

s += (d - 1);

byte *b = bytes;

// add each depth slice as a separate subdata

for(uint32_t di = 0; di < d; di++)

{

byte *depthslice = new byte[mipSlicePitch];

memcpy(depthslice, b, mipSlicePitch);

subdata.push_back(depthslice);

b += mipSlicePitch;

}

delete[] bytes;

}

}

// should have been handled above, but verify incoming data is RGBA8

if(sd.slice.slicesAsGrid && td.format.compByteWidth == 1 && td.format.compCount == 4)

{

uint32_t sliceWidth = td.width;

uint32_t sliceHeight = td.height;

uint32_t sliceGridHeight = (td.arraysize * td.depth) / sd.slice.sliceGridWidth;

if((td.arraysize * td.depth) % sd.slice.sliceGridWidth != 0)

sliceGridHeight++;

td.width *= sd.slice.sliceGridWidth;

td.height *= sliceGridHeight;

byte *combinedData = new byte[td.width * td.height * td.format.compCount];

memset(combinedData, 0, td.width * td.height * td.format.compCount);

for(size_t i = 0; i < subdata.size(); i++)

{

uint32_t gridx = (uint32_t)i % sd.slice.sliceGridWidth;

uint32_t gridy = (uint32_t)i / sd.slice.sliceGridWidth;

uint32_t yoffs = gridy * sliceHeight;

uint32_t xoffs = gridx * sliceWidth;

for(uint32_t y = 0; y < sliceHeight; y++)

{

for(uint32_t x = 0; x < sliceWidth; x++)

{

uint32_t *srcpix = (uint32_t *)&subdata[i][(y * sliceWidth + x) * 4 + 0];

uint32_t *dstpix = (uint32_t *)&combinedData[((y + yoffs) * td.width + x + xoffs) * 4 + 0];

*dstpix = *srcpix;

}

}

delete[] subdata[i];

}

subdata.resize(1);

subdata[0] = combinedData;

rowPitch = td.width * 4;

}

// should have been handled above, but verify incoming data is RGBA8 and 6 slices

if(sd.slice.cubeCruciform && td.format.compByteWidth == 1 && td.format.compCount == 4 &&

subdata.size() == 6)

{

uint32_t sliceWidth = td.width;

uint32_t sliceHeight = td.height;

td.width *= 4;

td.height *= 3;

byte *combinedData = new byte[td.width * td.height * td.format.compCount];

memset(combinedData, 0, td.width * td.height * td.format.compCount);

/*

uint32_t gridx[6] = {2, 0, 1, 1, 1, 3};

uint32_t gridy[6] = {1, 1, 0, 2, 1, 1};

for(size_t i = 0; i < subdata.size(); i++)

{

uint32_t yoffs = gridy[i] * sliceHeight;

uint32_t xoffs = gridx[i] * sliceWidth;

for(uint32_t y = 0; y < sliceHeight; y++)

{

for(uint32_t x = 0; x < sliceWidth; x++)

{

uint32_t *srcpix = (uint32_t *)&subdata[i][(y * sliceWidth + x) * 4 + 0];

uint32_t *dstpix = (uint32_t *)&combinedData[((y + yoffs) * td.width + x + xoffs) * 4 + 0];

*dstpix = *srcpix;

}

}

delete[] subdata[i];

}

subdata.resize(1);

subdata[0] = combinedData;

rowPitch = td.width * 4;

}

int numComps = td.format.compCount;

// if we want a grayscale image of one channel, splat it across all channels

// and set alpha to full

if(sd.channelExtract >= 0 && td.format.compByteWidth == 1 &&

(uint32_t)sd.channelExtract < td.format.compCount)

{

uint32_t cc = td.format.compCount;

for(uint32_t y = 0; y < td.height; y++)

{

for(uint32_t x = 0; x < td.width; x++)

{

subdata[0][(y * td.width + x) * cc + 0] =

subdata[0][(y * td.width + x) * cc + sd.channelExtract];

if(cc >= 2)

subdata[0][(y * td.width + x) * cc + 1] =

subdata[0][(y * td.width + x) * cc + sd.channelExtract];

if(cc >= 3)

subdata[0][(y * td.width + x) * cc + 2] =

subdata[0][(y * td.width + x) * cc + sd.channelExtract];

if(cc >= 4)

subdata[0][(y * td.width + x) * cc + 3] = 255;

}

}

}

// handle formats that don't support alpha

if(numComps == 4 && (sd.destType == FileType::BMP || sd.destType == FileType::JPG))

{

byte *nonalpha = new byte[td.width * td.height * 3];

for(uint32_t y = 0; y < td.height; y++)

{

for(uint32_t x = 0; x < td.width; x++)

{

byte r = subdata[0][(y * td.width + x) * 4 + 0];

byte g = subdata[0][(y * td.width + x) * 4 + 1];

byte b = subdata[0][(y * td.width + x) * 4 + 2];

byte a = subdata[0][(y * td.width + x) * 4 + 3];

if(sd.alpha != AlphaMapping::Discard)

{

FloatVector col = sd.alphaCol;

if(sd.alpha == AlphaMapping::BlendToCheckerboard)

{

bool lightSquare = ((x / 64) % 2) == ((y / 64) % 2);

col = lightSquare ? sd.alphaCol : sd.alphaColSecondary;

}

col.x = powf(col.x, 1.0f / 2.2f);

col.y = powf(col.y, 1.0f / 2.2f);

col.z = powf(col.z, 1.0f / 2.2f);

FloatVector pixel = FloatVector(float(r) / 255.0f, float(g) / 255.0f, float(b) / 255.0f,

float(a) / 255.0f);

pixel.x = pixel.x * pixel.w + col.x * (1.0f - pixel.w);

pixel.y = pixel.y * pixel.w + col.y * (1.0f - pixel.w);

pixel.z = pixel.z * pixel.w + col.z * (1.0f - pixel.w);

r = byte(pixel.x * 255.0f);

g = byte(pixel.y * 255.0f);

b = byte(pixel.z * 255.0f);

}

nonalpha[(y * td.width + x) * 3 + 0] = r;

nonalpha[(y * td.width + x) * 3 + 1] = g;

nonalpha[(y * td.width + x) * 3 + 2] = b;

}

}

delete[] subdata[0];

subdata[0] = nonalpha;

numComps = 3;

rowPitch = td.width * 3;

}

// assume that (R,G,0) is better mapping than (Y,A) for 2 component data

if(numComps == 2 && (sd.destType == FileType::BMP || sd.destType == FileType::JPG ||

sd.destType == FileType::PNG || sd.destType == FileType::TGA))

{

byte *rg0 = new byte[td.width * td.height * 3];

for(uint32_t y = 0; y < td.height; y++)

{

for(uint32_t x = 0; x < td.width; x++)

{

byte r = subdata[0][(y * td.width + x) * 2 + 0];

byte g = subdata[0][(y * td.width + x) * 2 + 1];

rg0[(y * td.width + x) * 3 + 0] = r;

rg0[(y * td.width + x) * 3 + 1] = g;

rg0[(y * td.width + x) * 3 + 2] = 0;

// if we're greyscaling the image, then keep the greyscale here.

if(sd.channelExtract >= 0)

rg0[(y * td.width + x) * 3 + 2] = r;

}

}

delete[] subdata[0];

subdata[0] = rg0;

numComps = 3;

rowPitch = td.width * 3;

}

FILE *f = FileIO::fopen(path, "wb");

if(!f)

{

success = false;

}

else

{

if(sd.destType == FileType::DDS)

{

dds_data ddsData;

ddsData.width = td.width;

ddsData.height = td.height;

ddsData.depth = td.depth;

ddsData.format = td.format;

ddsData.mips = numMips;

ddsData.slices = numSlices / td.depth;

ddsData.subdata = &subdata[0];

ddsData.cubemap = td.cubemap && numSlices == 6;

success = write_dds_to_file(f, ddsData);

}

else if(sd.destType == FileType::BMP)

{

int ret = stbi_write_bmp_to_func(fileWriteFunc, (void *)f, td.width, td.height, numComps,

subdata[0]);

success = (ret != 0);

}

else if(sd.destType == FileType::PNG)

{

// discard alpha if requested

for(uint32_t p = 0; sd.alpha == AlphaMapping::Discard && p < td.width * td.height; p++)

subdata[0][p * 4 + 3] = 255;

int ret = stbi_write_png_to_func(fileWriteFunc, (void *)f, td.width, td.height, numComps,

subdata[0], rowPitch);

success = (ret != 0);

}

else if(sd.destType == FileType::TGA)

{

// discard alpha if requested

for(uint32_t p = 0; sd.alpha == AlphaMapping::Discard && p < td.width * td.height; p++)

subdata[0][p * 4 + 3] = 255;

int ret = stbi_write_tga_to_func(fileWriteFunc, (void *)f, td.width, td.height, numComps,

subdata[0]);

success = (ret != 0);

}

else if(sd.destType == FileType::JPG)

{

jpge::params p;

p.m_quality = sd.jpegQuality;

int len = td.width * td.height * td.format.compCount;

// ensure buffer is at least 1024

if(len < 1024)

len = 1024;

char *jpgdst = new char[len];