void StAVPacket::setAVpkt(const AVPacket& theCopy) {
// free old data
free();
if(theCopy.data == NULL) {
return;
}
// copy values
myIsOwn = true;
myPacket = theCopy;
#if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55, 0, 0))
myPacket.buf = NULL;
#endif
// now copy data with special padding space
myPacket.data = stMemAllocAligned<uint8_t*>((theCopy.size + AV_INPUT_BUFFER_PADDING_SIZE), 16); // data must be aligned to 16 bytes for SSE!
stMemCpy (myPacket.data, theCopy.data, theCopy.size);
stMemZero(myPacket.data + (ptrdiff_t )theCopy.size, AV_INPUT_BUFFER_PADDING_SIZE);
#if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 118, 0))
if(myPacket.side_data_elems > 0) {
size_t aSize = theCopy.side_data_elems * sizeof(*theCopy.side_data);
// weird anonymouse structure...
uint8_t** aPtr = (uint8_t** )&myPacket.side_data;
*aPtr = stMemAllocZeroAligned<uint8_t*>(aSize, 16);
for(int anIter = 0; anIter < theCopy.side_data_elems; ++anIter) {
aSize = theCopy.side_data[anIter].size;
myPacket.side_data[anIter] = theCopy.side_data[anIter];
myPacket.side_data[anIter].data = stMemAllocAligned<uint8_t*>(aSize + AV_INPUT_BUFFER_PADDING_SIZE, 16);
stMemCpy (myPacket.side_data[anIter].data, theCopy.side_data[anIter].data, aSize);
stMemZero(myPacket.side_data[anIter].data + (ptrdiff_t )aSize, AV_INPUT_BUFFER_PADDING_SIZE);
}
}
#endif
}
bool StJpegParser::setupJps(const StFormatEnum theFormat) {
if(myBuffer == NULL) {
return false;
}
if(myOffsets[Offset_Jps] == 0) {
if(myOffsets[Offset_Dqt] == 0) {
return false;
}
// insert section right after DQT
const StCString THE_APP_DESC = stCString("Written by sView");
const uint16_t aDqtLen = StAlienData::Get16uBE(myBuffer + myOffsets[Offset_Dqt] + 2);
const ptrdiff_t anOffset = myOffsets[Offset_Dqt] + aDqtLen + 2;
const uint16_t aJpsLen = 16 + 2 + ((uint16_t )THE_APP_DESC.Size + 1);
if(!insertSection(M_APP3, aJpsLen, anOffset)) {
return false;
}
myOffsets[Offset_Jps] = anOffset;
stUByte_t* aData = myBuffer + anOffset + 2;
stMemCpy(aData + 2, "_JPSJPS_", 8);
StAlienData::Set16uBE(aData + 10, 4);
StAlienData::Set32uBE(aData + 12, 0);
StAlienData::Set16uBE(aData + 16, (uint16_t )THE_APP_DESC.Size);
stMemCpy(aData + 18, THE_APP_DESC.String, THE_APP_DESC.Size + 1);
} else if(myStFormat == theFormat) {
return false;
}
myStFormat = theFormat;
uint32_t aStereoDesc = 0x00000001;
switch(theFormat) {
case ST_V_SRC_PARALLEL_PAIR:
aStereoDesc |= SD_LAYOUT_SIDEBYSIDE | SD_LEFT_FIELD_FIRST;
break;
case ST_V_SRC_SIDE_BY_SIDE:
aStereoDesc |= SD_LAYOUT_SIDEBYSIDE;
break;
case ST_V_SRC_OVER_UNDER_LR:
aStereoDesc |= SD_LAYOUT_OVERUNDER | SD_LEFT_FIELD_FIRST;
break;
case ST_V_SRC_OVER_UNDER_RL:
aStereoDesc |= SD_LAYOUT_OVERUNDER;
break;
case ST_V_SRC_ROW_INTERLACE:
aStereoDesc |= SD_LAYOUT_INTERLEAVED;
break;
case ST_V_SRC_ANAGLYPH_RED_CYAN:
aStereoDesc |= SD_LAYOUT_ANAGLYPH;
break;
case ST_V_SRC_MONO:
default:
aStereoDesc = 0x00000000;
break;
}
StAlienData::Set32uBE(myBuffer + myOffsets[Offset_Jps] + 2 + 8 + 2 + 2, aStereoDesc);
return true;
}
bool StImagePlane::initCopy(const StImagePlane& theCopy) {
if(initTrash(theCopy.getFormat(), theCopy.getSizeX(), theCopy.getSizeY(), theCopy.getSizeRowBytes())) {
stMemCpy(changeData(), theCopy.getData(), theCopy.getSizeBytes());
return true;
}
return false;
}
/**
* Create context.
*/
bool create(const StString& theFile) {
if(myFormat == NULL) {
return false;
}
#if !defined(ST_LIBAV_FORK)
avformat_alloc_output_context2(&Context, myFormat, NULL, theFile.toCString());
#else
Context = avformat_alloc_context();
if(Context == NULL) {
return false;
}
Context->oformat = myFormat;
if(Context->oformat->priv_data_size > 0) {
Context->priv_data = av_mallocz(Context->oformat->priv_data_size);
if(!Context->priv_data) {
//goto nomem;
}
if(Context->oformat->priv_class) {
*(const AVClass**)Context->priv_data = Context->oformat->priv_class;
//av_opt_set_defaults(aCtxOut->priv_data);
}
} else {
Context->priv_data = NULL;
}
const size_t aStrLen = stMin(theFile.Size + 1, size_t(1024));
stMemCpy(Context->filename, theFile.toCString(), aStrLen);
Context->filename[1023] = '\0';
#endif
return Context != NULL;
}
bool StJpegParser::insertSection(const uint8_t theMarker,
const uint16_t theSectLen,
const ptrdiff_t theOffset) {
const size_t aDiff = size_t(theSectLen) + 2; // 2 bytes for marker
const size_t aNewSize = myLength + aDiff;
if(aNewSize > myBuffSize) {
myBuffSize = aNewSize + 256;
stUByte_t* aNewData = stMemAllocAligned<stUByte_t*>(myBuffSize);
if(aNewData == NULL) {
return false;
}
stMemCpy(aNewData, myBuffer, myLength);
if(myIsOwnData) {
stMemFreeAligned(myBuffer);
}
myIsOwnData = true;
// update pointers of image(s) data
for(StHandle<StJpegParser::Image> anImg = myImages;
!anImg.isNull(); anImg = anImg->Next) {
ptrdiff_t anOffset = anImg->Data - myBuffer;
if(anOffset >= theOffset) {
anOffset += aDiff;
}
anImg->Data = aNewData + anOffset;
if(!anImg->Thumb.isNull()) {
anOffset = anImg->Thumb->Data - myBuffer;
if(anOffset >= theOffset) {
anOffset += aDiff;
}
anImg->Thumb->Data = aNewData + anOffset;
}
}
myBuffer = aNewData;
}
myLength = aNewSize;
// update offset table
for(size_t anIter = 0; anIter < OffsetsNb; ++anIter) {
if(myOffsets[anIter] >= theOffset) {
myOffsets[anIter] += aDiff;
}
}
// initialize new section
const size_t aTailSize = myLength - theOffset;
std::memmove(myBuffer + theOffset + 2 + size_t(theSectLen),
myBuffer + theOffset,
aTailSize);
stUByte_t* aData = myBuffer + theOffset;
aData[0] = 0xFF;
aData[1] = theMarker;
StAlienData::Set16uBE(aData + 2, theSectLen);
return true;
}
bool StImagePlane::initSideBySide(const StImagePlane& theImageL,
const StImagePlane& theImageR,
const int theSeparationDx,
const int theSeparationDy,
const int theValue) {
if(theImageL.isNull() || theImageR.isNull()) {
// just ignore
return true;
}
if(theImageL.getSizeX() != theImageR.getSizeX() ||
theImageL.getSizeY() != theImageR.getSizeY()) {
// currently unsupported operation
return false;
}
size_t dxAbsPx = size_t(abs(theSeparationDx));
size_t dxLeftRPx = (theSeparationDx > 0) ? dxAbsPx : 0;
size_t dxLeftLPx = (theSeparationDx < 0) ? 2 * dxAbsPx : 0;
size_t dyAbsPx = size_t(abs(theSeparationDy));
size_t dyTopLPx = (theSeparationDy > 0) ? dyAbsPx : 0;
size_t dyTopRPx = (theSeparationDy < 0) ? dyAbsPx : 0;
size_t outSizeX = (theImageL.getSizeX() + dxAbsPx) * 2;
size_t outSizeY = theImageL.getSizeY() + dyAbsPx * 2;
setFormat(theImageL.getFormat());
if(!initZero(theImageL.getFormat(), outSizeX, outSizeY, outSizeX * theImageL.getSizePixelBytes(), theValue)) {
return false;
}
// save cross-eyed
for(size_t row = 0; row < theImageR.getSizeY(); ++row) {
stMemCpy(changeData(dyTopRPx + row, dxLeftRPx),
theImageR.getData(row, 0),
theImageR.getSizeRowBytes());
}
for(size_t row = 0; row < theImageR.getSizeY(); ++row) {
stMemCpy(changeData(dyTopLPx + row, theImageR.getSizeX() + dxLeftLPx + dxLeftRPx),
theImageL.getData(row, 0),
theImageL.getSizeRowBytes());
}
return true;
}
bool StImagePlane::fill(const StImagePlane& theCopy) {
if(getSizeY() != theCopy.getSizeY()
|| getSizeRowBytes() != theCopy.getSizeRowBytes()
|| getFormat() != theCopy.getFormat()) {
return initCopy(theCopy);
}
for(size_t row = 0; row < theCopy.getSizeY(); ++row) {
stMemCpy(changeData(row, 0),
theCopy.getData(row, 0),
theCopy.getSizeRowBytes());
}
return true;
}
StGLSharePointer* StGLRootWidget::getShare(const size_t theResId) {
if(theResId >= myShareSize) {
size_t aSizeNew = theResId + 10;
StGLSharePointer** anArrayNew = new StGLSharePointer*[aSizeNew];
stMemCpy(anArrayNew, myShareArray, myShareSize * sizeof(StGLSharePointer*));
delete[] myShareArray;
for(size_t aResId = myShareSize; aResId < aSizeNew; ++aResId) {
anArrayNew[aResId] = new StGLSharePointer();
}
myShareArray = anArrayNew;
myShareSize = aSizeNew;
}
return myShareArray[theResId];
}
bool StLangMap::open(const StString& theLngFilePath) {
myLngFile = theLngFilePath;
#ifdef _WIN32
// it is possible to use std::ifstream, but only for ANSI filenames
HANDLE inFile = CreateFileW(myLngFile.toUtfWide().toCString(), GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(inFile == INVALID_HANDLE_VALUE) {
ST_DEBUG_LOG("StLangMap, Failed to open language file \"" + myLngFile + '\"');
return false;
}
#else
std::ifstream inFile;
inFile.open(myLngFile.toCString());
if(inFile.fail()) {
ST_DEBUG_LOG("StLangMap, Failed to open language file \"" + myLngFile + '\"');
return false;
}
#endif
char bufferOrig[READ_BUFFER_SIZE]; bufferOrig[0] = '\0';
char* bufferLineOrig = new char[1];
bufferLineOrig[0] = '\0';
size_t aLineSize = 0;
StString bufferLineUTF;
bool isCont = false;
size_t oldLen = 0;
#ifdef _WIN32
DWORD aBytesRead = 0;
while(ReadFile(inFile, bufferOrig, READ_BUFFER_SIZE, &aBytesRead, NULL)) {
if(aBytesRead < 1) {
break;
}
#else
while(!inFile.eof()) {
inFile.read(bufferOrig, READ_BUFFER_SIZE);
const size_t aBytesRead = inFile.gcount();
if(aBytesRead < 1) {
break;
}
#endif
size_t lineStart = 0;
for(size_t c = 0; c < (size_t )aBytesRead; ++c) {
if(bufferOrig[c] == '\n') {
if(isCont) {
char* aCopy = new char[oldLen + c - lineStart + 1];
stMemCpy(&aCopy[0], bufferLineOrig, oldLen);
stMemCpy(&aCopy[oldLen], &bufferOrig[lineStart], (c - lineStart));
aLineSize = oldLen + c - lineStart;
delete[] bufferLineOrig;
bufferLineOrig = aCopy;
} else {
delete[] bufferLineOrig;
bufferLineOrig = new char[c - lineStart + 1];
stMemCpy(bufferLineOrig, &bufferOrig[lineStart], (c - lineStart));
aLineSize = c - lineStart;
}
// remove CR symbol if needed
if(aLineSize > 0 && bufferLineOrig[aLineSize - 1] == stUtf8_t(13)) {
--aLineSize;
}
bufferLineOrig[aLineSize] = '\0';
bufferLineUTF = StString(bufferLineOrig);
parseLine(bufferLineUTF);
lineStart = c + 1;
oldLen = 0;
isCont = false;
} else if(c == (READ_BUFFER_SIZE - 1)) {
char* aCopy = new char[oldLen + READ_BUFFER_SIZE - lineStart];
if(oldLen > 0) {
stMemCpy(aCopy, bufferLineOrig, oldLen);
}
stMemCpy(&aCopy[oldLen], &bufferOrig[lineStart], (READ_BUFFER_SIZE - lineStart));
delete[] bufferLineOrig;
bufferLineOrig = aCopy;
oldLen += (READ_BUFFER_SIZE - lineStart);
isCont = true;
}
if(!isCont) {
delete[] bufferLineOrig;
bufferLineOrig = new char[1];
bufferLineOrig[0] = '\0';
}
}
}
delete[] bufferLineOrig;
#ifdef _WIN32
CloseHandle(inFile);
#else
inFile.close();
#endif
ST_DEBUG_LOG("StLangMap, Loaded language file \"" + myLngFile + '\"');
return true;
}
StString& StLangMap::changeValue(const size_t theId) {
return myMap[theId];
}
const StString& StLangMap::getValue(const size_t theId) const {
const std::map<size_t, StString>::const_iterator anIter = myMap.find(theId);
return (anIter != myMap.end()) ? anIter->second : myEmptyStr;
}
StString& StLangMap::changeValueId(const size_t theId,
const char* theDefaultValue) {
StString& aValue = myMap[theId];
if(aValue.isEmpty()) {
if(myToShowId) {
aValue = StString('[') + theId + ']' + theDefaultValue;
} else {
aValue = theDefaultValue;
}
}
return aValue;
}
bool StFreeImage::save(const StString& theFilePath,
ImageType theImageType,
StFormatEnum ) {
if(!StFreeImage::init()) {
setState("FreeImage library is not initialized");
return false;
}
FREE_IMAGE_FORMAT aFIF = convertToFIF(theImageType);
if(aFIF == FIF_UNKNOWN) {
setState("FreeImage library, not supported image file format");
return false;
}
StImage stSaveImage;
if(getColorModel() != ImgColor_RGB && getColorModel() != ImgColor_RGBA && getColorModel() != ImgColor_GRAY) {
// convert from YUV and so on
if(!stSaveImage.initRGB(*this)) {
setState("StFreeImage, only RGB image could be saved");
return false;
}
} else {
stSaveImage.initWrapper(*this);
}
const StImagePlane& stImgPlane = stSaveImage.getPlane();
FREE_IMAGE_TYPE aSaveFormatFI = FIT_UNKNOWN;
if(!convertToFreeFormat(stImgPlane.getFormat(), aSaveFormatFI)) {
setState("StFreeImage, image format currently not supported");
return false;
}
// allocate FreeImage native structure
FIBITMAP* aSaveDIB = FreeImage_AllocateT(aSaveFormatFI, (int )stImgPlane.getSizeX(), (int )stImgPlane.getSizeY(),
(unsigned )stImgPlane.getSizePixelBytes() * 8, 0, 0, 0);
if(aSaveDIB == NULL) {
setState("FreeImage library, internal error");
FreeImage_Unload(aSaveDIB);
return false;
}
// wrapper the created data
StImagePlane stImgPlaneSave;
StImagePlane::ImgFormat stImgFormatSave = convertFromFreeFormat(FreeImage_GetImageType(aSaveDIB),
FreeImage_GetColorType(aSaveDIB),
FreeImage_GetBPP(aSaveDIB));
stImgPlaneSave.initWrapper(stImgFormatSave, FreeImage_GetBits(aSaveDIB),
FreeImage_GetWidth(aSaveDIB), FreeImage_GetHeight(aSaveDIB),
FreeImage_GetPitch(aSaveDIB));
// FreeImage data should be bottom-up...
stImgPlaneSave.setTopDown(false);
// copy from local structure to the FreeImage structure
size_t aRowInc = (( stImgPlaneSave.isTopDown() && stImgPlane.isTopDown()) ||
(!stImgPlaneSave.isTopDown() && !stImgPlane.isTopDown())) ? 1 : size_t(-1);
size_t aRowTo = (aRowInc == 1) ? 0 : (stImgPlane.getSizeY() - 1);
for(size_t aRowFrom = 0; aRowFrom < stImgPlane.getSizeY(); ++aRowFrom, aRowTo += aRowInc) {
for(size_t aCol = 0; aCol < stImgPlane.getSizeX(); ++aCol) {
stMemCpy(stImgPlaneSave.changeData(aRowTo, aCol), stImgPlane.getData(aRowFrom, aCol), stImgPlane.getSizePixelBytes());
}
}
// now save the image file!
#if defined(_WIN32)
if(!FreeImage_Save(aFIF, aSaveDIB, theFilePath.toUtfWide().toCString(), 0)) {
#else
if(!FreeImage_Save(aFIF, aSaveDIB, theFilePath.toCString(), 0)) {
#endif
setState("FreeImage library, image save failed");
FreeImage_Unload(aSaveDIB);
return false;
}
// free resources
FreeImage_Unload(aSaveDIB);
// set debug information
StString aDummy, aFileName;
StFileNode::getFolderAndFile(theFilePath, aDummy, aFileName);
setState(StString("FreeImage library, saved image '") + aFileName + "' " + getDescription());
return true;
}
bool StFreeImage::resize(size_t , size_t ) {
return false;
}
