int main (int argc, char **argv)
{
struct sockaddr_in sa;
int rc, i;
if (argc != 2)
{
printf ("Usage: %s num-sockets", argv[0]);
return (0);
}
max_socks = atoi (argv[1]);
if (max_socks == 0)
{
printf ("Usage: %s num-sockets", argv[0]);
return (0);
}
setup();
socks = calloc (max_socks, sizeof(int));
assert (socks != NULL);
for (i = 0; i < max_socks; i++)
{
PROFILE_START ("socket");
socks[i] = socket (AF_INET, SOCK_STREAM, 0);
PROFILE_STOP();
if (socks[i] < 0)
{
perror ("socket");
max_socks = i;
break;
}
}
for (i = 0; i < max_socks; i++)
{
sa.sin_family = AF_INET;
sa.sin_port = htons (test_port);
sa.sin_addr.s_addr = INADDR_ANY;
PROFILE_START ("bind");
rc = bind (socks[i], (struct sockaddr*)&sa, sizeof(sa));
PROFILE_STOP();
if (rc < 0)
{
perror ("bind");
break;
}
}
for (i = 0; i < max_socks; i++)
{
PROFILE_START ("close_s");
close_s (socks[i]);
PROFILE_STOP();
}
free (socks);
return (0);
}
void GroupOfPlanes::SearchMVs(MVGroupOfFrames *pSrcGOF, MVGroupOfFrames *pRefGOF,
SearchType searchType, int nSearchParam, int nPelSearch, int nLambda,
int lsad, int pnew, int plevel, bool global, int flags,
int *out, short *outfilebuf, int fieldShift, DCTClass * _DCT, int pzero, int pglobal, int badSAD, int badrange)
{
int i;
nFlags |= flags;
// write group's size
out[0] = GetArraySize();
// write validity : 1 in that case
out[1] = 1;
out += 2;
int fieldShiftCur = (nLevelCount - 1 == 0) ? fieldShift : 0; // may be non zero for finest level only
VECTOR globalMV; // create and init global motion vector as zero
globalMV.x = zeroMV.x;
globalMV.y = zeroMV.y;
globalMV.sad = zeroMV.sad;
if (!global)
pglobal = pzero;
int meanLumaChange = 0;
// Search the motion vectors, for the low details interpolations first
// Refining the search until we reach the highest detail interpolation.
// DebugPrintf("SearchMV level %i", nLevelCount-1);
planes[nLevelCount - 1]->SearchMVs(pSrcGOF->GetFrame(nLevelCount-1),
pRefGOF->GetFrame(nLevelCount-1),
searchType, nSearchParam, nLambda, lsad, pnew, plevel, flags,
out, &globalMV, outfilebuf, fieldShiftCur, _DCT, &meanLumaChange, divideExtra,
pzero, pglobal, badSAD, badrange);
out += planes[nLevelCount - 1]->GetArraySize(divideExtra);
for ( i = nLevelCount - 2; i >= 0; i-- )
{
int nSearchParamLevel = (i==0) ? nPelSearch : nSearchParam; // special case for finest level
PROFILE_START(MOTION_PROFILE_PREDICTION);
if (global)
{
planes[i+1]->EstimateGlobalMVDoubled(&globalMV); // get updated global MV (doubled)
// DebugPrintf("SearchMV globalMV %i, %i", globalMV.x, globalMV.y);
}
planes[i]->InterpolatePrediction(*(planes[i+1]));
PROFILE_STOP(MOTION_PROFILE_PREDICTION);
fieldShiftCur = (i == 0) ? fieldShift : 0; // may be non zero for finest level only
// DebugPrintf("SearchMV level %i", i);
planes[i]->SearchMVs(pSrcGOF->GetFrame(i), pRefGOF->GetFrame(i),
searchType, nSearchParamLevel, nLambda, lsad, pnew, plevel, flags,
out, &globalMV, outfilebuf, fieldShiftCur, _DCT, &meanLumaChange, divideExtra,
pzero, pglobal, badSAD, badrange);
out += planes[i]->GetArraySize(divideExtra);
}
}
static void
TestFIA_IOLoadColourArrayData(CuTest* tc)
{
FIBITMAP *dib1 = NULL, *dib2 = NULL;
FREE_IMAGE_TYPE type;
int bpp, err;
const char *file = "C:\\cup.tif";
dib1 = FIA_LoadFIBFromFile(file);
CuAssertTrue(tc, dib1 != NULL);
dib2 = FreeImage_AllocateT (FIT_BITMAP, FreeImage_GetWidth(dib1), FreeImage_GetHeight(dib1), 8, 0, 0, 0);
PROFILE_START("CopyColourBytesToFIBitmap");
for(int i=0; i < 1000; i++) {
//FIA_CopyColourBytesToFIBitmap (dib2, FreeImage_GetBits(dib1), 0, 1, COLOUR_ORDER_RGB);
FIA_CopyColourBytesTo8BitFIBitmap (dib2, FreeImage_GetBits(dib1), 24, FI_RGBA_RED, 0, 1);
}
PROFILE_STOP("CopyColourBytesToFIBitmap");
FIA_SaveFIBToFile (dib2, TEST_DATA_OUTPUT_DIR "/IO/save-colour-test.bmp", BIT8);
FreeImage_Unload(dib1);
FreeImage_Unload(dib2);
}
/**
* Combined threads and events loop.
*
* The loop processes first threads (_prepare_cb), then events
* (ev_stat_cb, ev_io_cb). It sleeps until the earliest thread resume
* time, or an I/O event occurs.
*
*/
int
mrkthr_loop(void)
{
int res;
PROFILE_START(mrkthr_sched0_p);
res = ev_run(the_loop, 0);
PROFILE_STOP(mrkthr_sched0_p);
return res;
}
static void
TestFIA_ErosionTest(CuTest* tc)
{
const char *file = TEST_DATA_DIR "\\morpholology_test.bmp";
FIBITMAP *dib1 = FIA_LoadFIBFromFile(file);
CuAssertTrue(tc, dib1 != NULL);
FIBITMAP *threshold_dib = FreeImage_Threshold(dib1, 20);
CuAssertTrue(tc, threshold_dib != NULL);
FIBITMAP *threshold_8bit_dib = FreeImage_ConvertTo8Bits(threshold_dib);
CuAssertTrue(tc, threshold_8bit_dib != NULL);
FIABITMAP *border_dib = FIA_SetBorder(threshold_8bit_dib, 2, 2
, BorderType_Constant, 0.0);
PROFILE_START("ErosionFilter");
FilterKernel kernel = FIA_NewKernel(2, 2, kernel_values, 1.0);
FIBITMAP* result_dib = FIA_BinaryErosion(border_dib, kernel);
CuAssertTrue(tc, result_dib != NULL);
PROFILE_STOP("ErosionFilter");
FIA_SaveFIBToFile(result_dib, TEST_DATA_OUTPUT_DIR "\\erosion_result.jpg", BIT24);
result_dib = FIA_BinaryInnerBorder(threshold_8bit_dib);
FIA_SimpleSaveFIBToFile(result_dib, TEST_DATA_OUTPUT_DIR "morphology/inner_border_result.bmp");
FreeImage_Unload(dib1);
FreeImage_Unload(threshold_dib);
FreeImage_Unload(threshold_8bit_dib);
FIA_Unload(border_dib);
FreeImage_Unload(result_dib);
}
static void TestFIA_HistogramTest(CuTest* tc)
{
const char *file= TEST_DATA_DIR "drone-bee-greyscale.jpg";
FIBITMAP *dib = FIA_LoadFIBFromFile(file);
CuAssertTrue(tc, dib != NULL);
unsigned long hist[256];
PROFILE_START("FreeImageAlgorithms_Histogram");
if (FIA_Histogram(dib, 0, 255, 2, hist) == FIA_ERROR) {
CuFail(tc, "Failed");
}
PROFILE_STOP("FreeImageAlgorithms_Histogram");
FreeImage_Unload(dib);
}
static void TestFIA_CentroidTest(CuTest* tc)
{
const char *file= TEST_DATA_DIR "drone-bee-greyscale.jpg";
FIBITMAP *dib = FIA_LoadFIBFromFile(file);
CuAssertTrue(tc, dib != NULL);
PROFILE_START("FreeImageAlgorithms_StatisticReport");
float x_centroid, y_centroid;
if (FIA_Centroid(dib, &x_centroid, &y_centroid) == FIA_ERROR) {
CuFail(tc, "Failed");
}
PROFILE_STOP("FreeImageAlgorithms_StatisticReport");
FreeImage_Unload(dib);
}
std::string cache_read() {
PROFILE_FUNC();
std::string data;
PROFILE_START(action_find); // Starts new action which will be inner to ACTION_READ
bool found = find_record();
PROFILE_STOP(action_find);
if (!found) {
PROFILE_BLOCK(load_from_disk);
data = read_from_disk();
put_into_cache(data);
return data; // Here all action guards are destructed and actions are correctly finished
}
data = load_from_cache();
return data;
}
void MVFlowInter::ProcessFrameIntoGroupOfFrames(PMVGroupOfFrames *srcGOF, PVideoFrame *src, PVideoFrame *src2x,
int const Sharp, int const pixelType, int const nHeight, int const nWidth,
int const nPel, bool const isse)
{
(*srcGOF)->ConvertVideoFrame(src, src2x, pixelType, nWidth, nHeight, nPel, isse);
PROFILE_START(MOTION_PROFILE_INTERPOLATION);
if (*src2x) {
// do nothing
}
else {
(*srcGOF)->Pad(YUVPLANES);
(*srcGOF)->Refine(YUVPLANES, Sharp);
}
PROFILE_STOP(MOTION_PROFILE_INTERPOLATION);
// set processed
(*srcGOF)->SetProcessed();
}
/*
* Our WinPcap send function.
* Not sure if partial writes are possible with NPF. Retry if rc != length.
*/
int pkt_send (const void *tx, int length)
{
const ADAPTER *adapter;
PACKET pkt;
int tx_cnt, rc = 0;
ASSERT_PKT_INF (0);
adapter = (const ADAPTER*) _pkt_inf->adapter;
PROFILE_START ("pkt_send");
for (tx_cnt = 1 + pkt_txretries; tx_cnt > 0; tx_cnt--)
{
pkt.Buffer = (void*) tx;
pkt.Length = length;
if (PacketSendPacket (adapter, &pkt, TRUE))
{
rc = length;
break;
}
STAT (macstats.num_tx_retry++);
}
if (rc == length)
{
num_tx_pkt++;
num_tx_bytes += length;
}
else
{
num_tx_errors++; /* local copy */
STAT (macstats.num_tx_err++);
}
PROFILE_STOP();
return (rc);
}
int
poller_resume(mrkthr_ctx_t *ctx)
{
int res;
/*
* Can only be the result of yield or start, ie, the state cannot be
* dormant or resumed.
*/
if (!(ctx->co.state & CO_STATE_RESUMABLE)) {
/* This is an error (currently no reason is known, though) */
sleepq_remove(ctx);
/* not sure if we can push it here ... */
push_free_ctx(ctx);
TRRET(RESUME + 1);
}
ctx->co.state = CO_STATE_RESUMED;
me = ctx;
#ifdef TRACE_VERBOSE
CTRACE("resuming >>>");
//mrkthr_dump(ctx);
#endif
PROFILE_STOP(mrkthr_sched0_p);
PROFILE_START(mrkthr_swap_p);
res = swapcontext(&main_uc, &me->co.uc);
PROFILE_STOP(mrkthr_swap_p);
PROFILE_START(mrkthr_sched0_p);
#ifdef TRACE_VERBOSE
CTRACE("back from resume <<<");
//mrkthr_dump(me);
#endif
if (errno == EINTR) {
CTRACE("ignoring EINTR");
#ifdef TRACE_VERBOSE
//mrkthr_dump(ctx);
#endif
errno = 0;
return 0;
}
/* no one in the thread context may touch me */
assert(me == ctx);
me = NULL;
if (ctx->co.state & CO_STATE_RESUMABLE) {
return ctx->co.rc;
} else if (ctx->co.state == CO_STATE_RESUMED) {
/*
* This is the case of the exited (dead) thread.
*/
#ifdef TRACE_VERBOSE
CTRACE("Assuming exited (dead) ...");
//mrkthr_dump(ctx);
#endif
sleepq_remove(ctx);
push_free_ctx(ctx);
//TRRET(RESUME + 2);
//return MRKTHR_CO_RC_EXITED;
return ctx->co.rc;
} else {
CTRACE("Unknown case:");
mrkthr_dump(ctx);
FAIL("resume");
}
return res;
}
PVideoFrame __stdcall MVAnalyse::GetFrame(int n, IScriptEnvironment* env)
{
const unsigned char *pSrcY, *pSrcU, *pSrcV;
const unsigned char *pRefY, *pRefU, *pRefV;
unsigned char *pDst;
int nSrcPitchY, nSrcPitchUV;
int nRefPitchY, nRefPitchUV;
int minframe, maxframe, nref;
if (analysisData.nDeltaFrame > 0)
{
minframe = ( analysisData.isBackward ) ? 0 : analysisData.nDeltaFrame;
maxframe = ( analysisData.isBackward ) ? vi.num_frames - analysisData.nDeltaFrame : vi.num_frames;
int offset = ( analysisData.isBackward ) ? analysisData.nDeltaFrame : -analysisData.nDeltaFrame;
nref = n + offset;
}
else // special static mode
{
nref = - analysisData.nDeltaFrame; // positive fixed frame number
minframe = 0;
maxframe = vi.num_frames;
}
// DebugPrintf("MVAnalyse: Get src frame %d",n);
PVideoFrame src = child->GetFrame(n, env); // v2.0
bool paritysrc = child->GetParity(n);
PROFILE_START(MOTION_PROFILE_YUY2CONVERT);
if ( (analysisData.pixelType & VideoInfo::CS_YUY2) == VideoInfo::CS_YUY2 )
{
// planer data packed to interleaved format (same as interleved2planar by kassandro) - v2.0.0.5
pSrcY = src->GetReadPtr();
pSrcU = pSrcY + src->GetRowSize()/2;
pSrcV = pSrcU + src->GetRowSize()/4;
nSrcPitchY = src->GetPitch();
nSrcPitchUV = nSrcPitchY;
}
else
{
pSrcY = src->GetReadPtr(PLANAR_Y);
pSrcU = src->GetReadPtr(PLANAR_U);
pSrcV = src->GetReadPtr(PLANAR_V);
nSrcPitchY = src->GetPitch(PLANAR_Y);
nSrcPitchUV = src->GetPitch(PLANAR_U);
}
PROFILE_STOP(MOTION_PROFILE_YUY2CONVERT);
PVideoFrame dst;
dst = env->NewVideoFrame(vi);
pDst = dst->GetWritePtr();
// write analysis parameters as a header to frame
memcpy(pDst, &headerSize, sizeof(int));
if (divideExtra)
memcpy(pDst+sizeof(int), &analysisDataDivided, sizeof(analysisData));
else
memcpy(pDst+sizeof(int), &analysisData, sizeof(analysisData));
pDst += headerSize;
// DebugPrintf("MVAnalyse: Get ref frame %d",n + offset);
// DebugPrintf("MVAnalyse frame %i backward=%i", n, analysisData.isBackward);
if (( n < maxframe ) && ( n >= minframe ))
{
PVideoFrame ref = child->GetFrame(nref, env);
bool parityref = child->GetParity(nref);
int fieldShift = 0;
if (vi.IsFieldBased() && analysisData.nPel > 1 && (analysisData.nDeltaFrame %2 != 0))
{
fieldShift = (paritysrc && !parityref) ? analysisData.nPel/2 : ( (parityref && !paritysrc) ? -(analysisData.nPel/2) : 0);
// vertical shift of fields for fieldbased video at finest level pel2
}
PROFILE_START(MOTION_PROFILE_YUY2CONVERT);
if ( (analysisData.pixelType & VideoInfo::CS_YUY2) == VideoInfo::CS_YUY2 )
{
// planer data packed to interleaved format (same as interleved2planar by kassandro) - v2.0.0.5
pRefY = ref->GetReadPtr();
pRefU = pRefY + ref->GetRowSize()/2;
pRefV = pRefU + ref->GetRowSize()/4;
nRefPitchY = ref->GetPitch();
nRefPitchUV = nRefPitchY;
}
else
{
pRefY = ref->GetReadPtr(PLANAR_Y);
pRefU = ref->GetReadPtr(PLANAR_U);
pRefV = ref->GetReadPtr(PLANAR_V);
nRefPitchY = ref->GetPitch(PLANAR_Y);
nRefPitchUV = ref->GetPitch(PLANAR_U);
}
PROFILE_STOP(MOTION_PROFILE_YUY2CONVERT);
pSrcGOF->Update(nModeYUV, (BYTE*)pSrcY, nSrcPitchY, (BYTE*)pSrcU, nSrcPitchUV, (BYTE*)pSrcV, nSrcPitchUV); // v2.0
pRefGOF->Update(nModeYUV, (BYTE*)pRefY, nRefPitchY, (BYTE*)pRefU, nRefPitchUV, (BYTE*)pRefV, nRefPitchUV); // v2.0
if (outfile != NULL) {
fwrite( &n, sizeof( int ), 1, outfile );// write frame number
}
int *pVecPrevOrNull = nVecPrev==n-1 ? pVecPrev : 0; // temporal predictor dst if prev frame was really prev
vectorFields->SearchMVs(pSrcGOF, pRefGOF, searchType, nSearchParam, nPelSearch, nLambda, lsad, pnew, plevel, global,
analysisData.nFlags, reinterpret_cast<int*>(pDst), outfilebuf, fieldShift, DCTc, pzero, pglobal, badSAD, badrange, meander, pVecPrevOrNull, tryMany);
if (divideExtra) {
// make extra level with divided sublocks with median (not estimated) motion
vectorFields->ExtraDivide(reinterpret_cast<int*>(pDst), analysisData.nFlags);
}
// PROFILE_CUMULATE();
if (outfile != NULL)
fwrite( outfilebuf, sizeof(short)* analysisData.nBlkX*analysisData.nBlkY*4, 1, outfile );
}
else
{
vectorFields->WriteDefaultToArray(reinterpret_cast<int*>(pDst));
}
if (pVecPrev) {
memcpy(pVecPrev, reinterpret_cast<int*>(pDst), vectorFields->GetArraySize()); // store previous vectors for use as predictor in next frame
nVecPrev = n;
}
return dst;
}
void ProcessAdjacentMapTile(Path& thePath, Tile* tile, Map* map, const IntVec2& start, const IntVec2& goal ){
UNUSED(start);
PROFILE_SECTION();
if (tile == NULL)
return;
//8 Get adjacent pos
MapPosition& adjacentNodePos = tile->m_mapPosition;
//float newFinalCostCheck = newPathNode->m_nodeCost.h;
//if (newFinalCostCheck < 2.0f * map->m_size.x * map->m_size.y){
//9 if (adjacent pos on closed list) //continue;
Tile* tileToCheckID = map->GetTileAtMapPosition(adjacentNodePos);
bool tileCheckID;
//tilesPathIDCritSec.Enter();
tileCheckID = (tileToCheckID->m_inClosedListOfPathID == thePath.m_id);
//tilesPathIDCritSec.Exit();
if (tileCheckID){
//if (thePath.IsMapPositionInClosedList(adjacentNodePos)){
return;
}
else{
//10 & 11 decently fast
// 10 if (not on open list){
if(tileToCheckID->m_inOpenListOfPathID != thePath.m_id){
//if (!thePath.IsMapPositionInOpenList(adjacentNodePos)){
PROFILE_START(step 10 and 11);
//11 build new pathnode(local G, parentG = ActiveNode.G) // Add to OpenList
PathNode* newPathNode = new PathNode(tile, thePath.m_activeNode, goal, thePath.m_bestAvoidCost); //this bit of path node has a memory leak
thePath.AddToOpenList(newPathNode);
tilesPathIDOpenCritSec.Enter();
tile->m_inOpenListOfPathID = thePath.m_id;
tilesPathIDOpenCritSec.Exit();
PROFILE_STOP();
return;
}
else{
//is on openList
float altTotalG;
float tileAvoidCost;
float currentG;
PathNode* nodeInOpenList;
PROFILE_START(step 12 and 13); //doesn't seem to ever get called
tileAvoidCost = tile->m_tileAvoidanceCost;
nodeInOpenList = thePath.GetPathNodeAtMapPositionFromOpenList(adjacentNodePos);
if (!nodeInOpenList){
return;
}
//12 calc newG as calc hypothetical G to this node
altTotalG = CalcHypotheticalGCostToAdjacentNodePosition(thePath.m_activeNode, adjacentNodePos, tileAvoidCost);
//13 compare to G in openList for node holding this position
currentG = nodeInOpenList->m_nodeCost.g;
PROFILE_STOP();
//14 if better <
if (altTotalG < currentG){
//15 update openListNode, update localG, parent,
PROFILE_START(step 15);
ReplaceOpenListPathNode(thePath, nodeInOpenList, tileAvoidCost);
PROFILE_STOP();
return;
}
else{
//16 if worse or equal >= //throw out
return;
}//end of inside if/else
}//end of if/else
}//end of outer if/else
}
PVideoFrame __stdcall MVSuper::GetFrame(int n, IScriptEnvironment* env)
{
const unsigned char *pSrcY, *pSrcU, *pSrcV;
unsigned char *pDstY, *pDstU, *pDstV;
const unsigned char *pSrcPelY, *pSrcPelU, *pSrcPelV;
// unsigned char *pDstYUY2;
int nSrcPitchY, nSrcPitchUV;
int nDstPitchY, nDstPitchUV;
int nSrcPelPitchY, nSrcPelPitchUV;
// int nDstPitchYUY2;
DebugPrintf("MSuper: Get src frame %d clip %d",n,child);
PVideoFrame src = child->GetFrame(n, env);
PVideoFrame srcPel;
if (usePelClip)
srcPel = pelclip->GetFrame(n, env);
PVideoFrame dst = env->NewVideoFrame(vi);
PROFILE_START(MOTION_PROFILE_YUY2CONVERT);
if ( (pixelType & VideoInfo::CS_YUY2) == VideoInfo::CS_YUY2 )
{
if (!planar)
{
pSrcY = SrcPlanes->GetPtr();
pSrcU = SrcPlanes->GetPtrU();
pSrcV = SrcPlanes->GetPtrV();
nSrcPitchY = SrcPlanes->GetPitch();
nSrcPitchUV = SrcPlanes->GetPitchUV();
YUY2ToPlanes(src->GetReadPtr(), src->GetPitch(), nWidth, nHeight,
pSrcY, nSrcPitchY, pSrcU, pSrcV, nSrcPitchUV, isse);
if (usePelClip)
{
pSrcPelY = SrcPelPlanes->GetPtr();
pSrcPelU = SrcPelPlanes->GetPtrU();
pSrcPelV = SrcPelPlanes->GetPtrV();
nSrcPelPitchY = SrcPelPlanes->GetPitch();
nSrcPelPitchUV = SrcPelPlanes->GetPitchUV();
YUY2ToPlanes(srcPel->GetReadPtr(), srcPel->GetPitch(), srcPel->GetRowSize()/2, srcPel->GetHeight(),
pSrcPelY, nSrcPelPitchY, pSrcPelU, pSrcPelV, nSrcPelPitchUV, isse);
}
}
else
{
pSrcY = src->GetReadPtr();
pSrcU = pSrcY + src->GetRowSize()/2;
pSrcV = pSrcU + src->GetRowSize()/4;
nSrcPitchY = src->GetPitch();
nSrcPitchUV = nSrcPitchY;
if (usePelClip)
{
pSrcPelY = srcPel->GetReadPtr();
pSrcPelU = pSrcPelY + srcPel->GetRowSize()/2;
pSrcPelV = pSrcPelU + srcPel->GetRowSize()/4;
nSrcPelPitchY = srcPel->GetPitch();
nSrcPelPitchUV = nSrcPelPitchY;
}
}
// pDstY = DstPlanes->GetPtr();
// pDstU = DstPlanes->GetPtrU();
// pDstV = DstPlanes->GetPtrV();
// nDstPitchY = DstPlanes->GetPitch();
// nDstPitchUV = DstPlanes->GetPitchUV();
// planer data packed to interleaved format (same as interleved2planar by kassandro) - v2.0.0.5
pDstY = dst->GetWritePtr();
pDstU = pDstY + nSuperWidth;
pDstV = pDstU + nSuperWidth/2;
nDstPitchY = dst->GetPitch();
nDstPitchUV = nDstPitchY;
}
else
{
pSrcY = src->GetReadPtr(PLANAR_Y);
pSrcU = src->GetReadPtr(PLANAR_U);
pSrcV = src->GetReadPtr(PLANAR_V);
nSrcPitchY = src->GetPitch(PLANAR_Y);
nSrcPitchUV = src->GetPitch(PLANAR_U);
if (usePelClip)
{
pSrcPelY = srcPel->GetReadPtr(PLANAR_Y);
pSrcPelU = srcPel->GetReadPtr(PLANAR_U);
pSrcPelV = srcPel->GetReadPtr(PLANAR_V);
nSrcPelPitchY = srcPel->GetPitch(PLANAR_Y);
nSrcPelPitchUV = srcPel->GetPitch(PLANAR_U);
}
pDstY = dst->GetWritePtr(PLANAR_Y);
pDstU = dst->GetWritePtr(PLANAR_U);
pDstV = dst->GetWritePtr(PLANAR_V);
nDstPitchY = dst->GetPitch(PLANAR_Y);
nDstPitchUV = dst->GetPitch(PLANAR_U);
}
PROFILE_STOP(MOTION_PROFILE_YUY2CONVERT);
PROFILE_START(MOTION_PROFILE_INTERPOLATION);
pSrcGOF->Update(YUVPLANES, pDstY, nDstPitchY, pDstU, nDstPitchUV, pDstV, nDstPitchUV);
pSrcGOF->SetPlane(pSrcY, nSrcPitchY, YPLANE);
pSrcGOF->SetPlane(pSrcU, nSrcPitchUV, UPLANE);
pSrcGOF->SetPlane(pSrcV, nSrcPitchUV, VPLANE);
pSrcGOF->Reduce(nModeYUV);
pSrcGOF->Pad(nModeYUV);
if (usePelClip)
{
MVFrame *srcFrames = pSrcGOF->GetFrame(0);
MVPlane *srcPlaneY = srcFrames->GetPlane(YPLANE);
if (nModeYUV & YPLANE) srcPlaneY->RefineExt(pSrcPelY, nSrcPelPitchY, isPelClipPadded);
MVPlane *srcPlaneU = srcFrames->GetPlane(UPLANE);
if (nModeYUV & UPLANE) srcPlaneU->RefineExt(pSrcPelU, nSrcPelPitchUV, isPelClipPadded);
MVPlane *srcPlaneV = srcFrames->GetPlane(VPLANE);
if (nModeYUV & VPLANE) srcPlaneV->RefineExt(pSrcPelV, nSrcPelPitchUV, isPelClipPadded);
}
else
{
pSrcGOF->Refine(nModeYUV);
}
PROFILE_STOP(MOTION_PROFILE_INTERPOLATION);
/*
PROFILE_START(MOTION_PROFILE_YUY2CONVERT);
if ( (pixelType & VideoInfo::CS_YUY2) == VideoInfo::CS_YUY2 )
{
pDstYUY2 = dst->GetWritePtr();
nDstPitchYUY2 = dst->GetPitch();
YUY2FromPlanes(pDstYUY2, nDstPitchYUY2, nSuperWidth, nSuperHeight,
pDstY, nDstPitchY, pDstU, pDstV, nDstPitchUV, isse);
}
PROFILE_STOP(MOTION_PROFILE_YUY2CONVERT);
*/
PROFILE_CUMULATE();
return dst;
}
PVideoFrame __stdcall MVDegrain1::GetFrame(int n, IScriptEnvironment* env)
{
int nWidth_B = nBlkX*(nBlkSizeX - nOverlapX) + nOverlapX;
int nHeight_B = nBlkY*(nBlkSizeY - nOverlapY) + nOverlapY;
PVideoFrame src = child->GetFrame(n, env);
PVideoFrame dst;
BYTE *pDst[3], *pDstCur[3];
const BYTE *pSrcCur[3];
const BYTE *pSrc[3];
const BYTE *pRefB[3];
const BYTE *pRefF[3];
int nDstPitches[3], nSrcPitches[3];
int nRefBPitches[3], nRefFPitches[3];
unsigned char *pDstYUY2;
const unsigned char *pSrcYUY2;
int nDstPitchYUY2;
int nSrcPitchYUY2;
bool isUsableB, isUsableF;
int tmpPitch = nBlkSizeX;
int nLogPel = (nPel==4) ? 2 : (nPel==2) ? 1 : 0;
// nLogPel=0 for nPel=1, 1 for nPel=2, 2 for nPel=4, i.e. (x*nPel) = (x<<nLogPel)
PVideoFrame mvF = mvClipF.GetFrame(n, env);
mvClipF.Update(mvF, env);
isUsableF = mvClipF.IsUsable();
mvF = 0; // v2.0.9.2 - it seems, we do not need in vectors clip anymore when we finished copiing them to fakeblockdatas
PVideoFrame mvB = mvClipB.GetFrame(n, env);
mvClipB.Update(mvB, env);
isUsableB = mvClipB.IsUsable();
mvB = 0;
int lsb_offset_y = 0;
int lsb_offset_u = 0;
int lsb_offset_v = 0;
// int sharp = mvClipB.GetSharp();
int ySubUV = (yRatioUV == 2) ? 1 : 0;
// if ( mvClipB.IsUsable() && mvClipF.IsUsable() && mvClipB2.IsUsable() && mvClipF2.IsUsable() )
// {
dst = env->NewVideoFrame(vi);
if ( (pixelType & VideoInfo::CS_YUY2) == VideoInfo::CS_YUY2 )
{
if (!planar)
{
pDstYUY2 = dst->GetWritePtr();
nDstPitchYUY2 = dst->GetPitch();
pDst[0] = DstPlanes->GetPtr();
pDst[1] = DstPlanes->GetPtrU();
pDst[2] = DstPlanes->GetPtrV();
nDstPitches[0] = DstPlanes->GetPitch();
nDstPitches[1] = DstPlanes->GetPitchUV();
nDstPitches[2] = DstPlanes->GetPitchUV();
pSrcYUY2 = src->GetReadPtr();
nSrcPitchYUY2 = src->GetPitch();
pSrc[0] = SrcPlanes->GetPtr();
pSrc[1] = SrcPlanes->GetPtrU();
pSrc[2] = SrcPlanes->GetPtrV();
nSrcPitches[0] = SrcPlanes->GetPitch();
nSrcPitches[1] = SrcPlanes->GetPitchUV();
nSrcPitches[2] = SrcPlanes->GetPitchUV();
YUY2ToPlanes(pSrcYUY2, nSrcPitchYUY2, nWidth, nHeight,
pSrc[0], nSrcPitches[0], pSrc[1], pSrc[2], nSrcPitches[1], isse);
}
else
{
pDst[0] = dst->GetWritePtr();
pDst[1] = pDst[0] + nWidth;
pDst[2] = pDst[1] + nWidth/2;
nDstPitches[0] = dst->GetPitch();
nDstPitches[1] = nDstPitches[0];
nDstPitches[2] = nDstPitches[0];
pSrc[0] = src->GetReadPtr();
pSrc[1] = pSrc[0] + nWidth;
pSrc[2] = pSrc[1] + nWidth/2;
nSrcPitches[0] = src->GetPitch();
nSrcPitches[1] = nSrcPitches[0];
nSrcPitches[2] = nSrcPitches[0];
}
}
else
{
pDst[0] = YWPLAN(dst);
pDst[1] = UWPLAN(dst);
pDst[2] = VWPLAN(dst);
nDstPitches[0] = YPITCH(dst);
nDstPitches[1] = UPITCH(dst);
nDstPitches[2] = VPITCH(dst);
pSrc[0] = YRPLAN(src);
pSrc[1] = URPLAN(src);
pSrc[2] = VRPLAN(src);
nSrcPitches[0] = YPITCH(src);
nSrcPitches[1] = UPITCH(src);
nSrcPitches[2] = VPITCH(src);
}
lsb_offset_y = nDstPitches [0] * nHeight;
lsb_offset_u = nDstPitches [1] * (nHeight / yRatioUV);
lsb_offset_v = nDstPitches [2] * (nHeight / yRatioUV);
if (lsb_flag)
{
memset (pDst [0] + lsb_offset_y, 0, lsb_offset_y);
if (! planar)
{
memset (pDst [1] + lsb_offset_u, 0, lsb_offset_u);
memset (pDst [2] + lsb_offset_v, 0, lsb_offset_v);
}
}
// MVFrames *pFrames = mvCore->GetFrames(nIdx);
PVideoFrame refB, refF;
// PVideoFrame refB2x, refF2x;
mvClipF.use_ref_frame (refF, isUsableF, super, n, env);
mvClipB.use_ref_frame (refB, isUsableB, super, n, env);
if ( (pixelType & VideoInfo::CS_YUY2) == VideoInfo::CS_YUY2 )
{
// planar data packed to interleaved format (same as interleved2planar by kassandro) - v2.0.0.5
if (isUsableF)
{
pRefF[0] = refF->GetReadPtr();
pRefF[1] = pRefF[0] + refF->GetRowSize()/2;
pRefF[2] = pRefF[1] + refF->GetRowSize()/4;
nRefFPitches[0] = refF->GetPitch();
nRefFPitches[1] = nRefFPitches[0];
nRefFPitches[2] = nRefFPitches[0];
}
if (isUsableB)
{
pRefB[0] = refB->GetReadPtr();
pRefB[1] = pRefB[0] + refB->GetRowSize()/2;
pRefB[2] = pRefB[1] + refB->GetRowSize()/4;
nRefBPitches[0] = refB->GetPitch();
nRefBPitches[1] = nRefBPitches[0];
nRefBPitches[2] = nRefBPitches[0];
}
}
else
{
if (isUsableF)
{
pRefF[0] = YRPLAN(refF);
pRefF[1] = URPLAN(refF);
pRefF[2] = VRPLAN(refF);
nRefFPitches[0] = YPITCH(refF);
nRefFPitches[1] = UPITCH(refF);
nRefFPitches[2] = VPITCH(refF);
}
if (isUsableB)
{
pRefB[0] = YRPLAN(refB);
pRefB[1] = URPLAN(refB);
pRefB[2] = VRPLAN(refB);
nRefBPitches[0] = YPITCH(refB);
nRefBPitches[1] = UPITCH(refB);
nRefBPitches[2] = VPITCH(refB);
}
}
MVPlane *pPlanesB[3] = { 0 };
MVPlane *pPlanesF[3] = { 0 };
if (isUsableF)
{
pRefFGOF->Update(YUVplanes, (BYTE*)pRefF[0], nRefFPitches[0], (BYTE*)pRefF[1], nRefFPitches[1], (BYTE*)pRefF[2], nRefFPitches[2]);
if (YUVplanes & YPLANE)
pPlanesF[0] = pRefFGOF->GetFrame(0)->GetPlane(YPLANE);
if (YUVplanes & UPLANE)
pPlanesF[1] = pRefFGOF->GetFrame(0)->GetPlane(UPLANE);
if (YUVplanes & VPLANE)
pPlanesF[2] = pRefFGOF->GetFrame(0)->GetPlane(VPLANE);
}
if (isUsableB)
{
pRefBGOF->Update(YUVplanes, (BYTE*)pRefB[0], nRefBPitches[0], (BYTE*)pRefB[1], nRefBPitches[1], (BYTE*)pRefB[2], nRefBPitches[2]);// v2.0
if (YUVplanes & YPLANE)
pPlanesB[0] = pRefBGOF->GetFrame(0)->GetPlane(YPLANE);
if (YUVplanes & UPLANE)
pPlanesB[1] = pRefBGOF->GetFrame(0)->GetPlane(UPLANE);
if (YUVplanes & VPLANE)
pPlanesB[2] = pRefBGOF->GetFrame(0)->GetPlane(VPLANE);
}
PROFILE_START(MOTION_PROFILE_COMPENSATION);
pDstCur[0] = pDst[0];
pDstCur[1] = pDst[1];
pDstCur[2] = pDst[2];
pSrcCur[0] = pSrc[0];
pSrcCur[1] = pSrc[1];
pSrcCur[2] = pSrc[2];
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// LUMA plane Y
if (!(YUVplanes & YPLANE))
{
BitBlt(pDstCur[0], nDstPitches[0], pSrcCur[0], nSrcPitches[0], nWidth, nHeight, isse);
}
else
{
if (nOverlapX==0 && nOverlapY==0)
{
for (int by=0; by<nBlkY; by++)
{
int xx = 0;
for (int bx=0; bx<nBlkX; bx++)
{
int i = by*nBlkX + bx;
const BYTE * pB, *pF;
int npB, npF;
int WSrc, WRefB, WRefF;
use_block_y (pB , npB , WRefB , isUsableB , mvClipB , i, pPlanesB [0], pSrcCur [0], xx, nSrcPitches [0]);
use_block_y (pF , npF , WRefF , isUsableF , mvClipF , i, pPlanesF [0], pSrcCur [0], xx, nSrcPitches [0]);
norm_weights (WSrc, WRefB, WRefF);
// luma
DEGRAINLUMA(pDstCur[0] + xx, pDstCur[0] + lsb_offset_y + xx,
lsb_flag, nDstPitches[0], pSrcCur[0]+ xx, nSrcPitches[0],
pB, npB, pF, npF, WSrc, WRefB, WRefF);
xx += (nBlkSizeX);
if (bx == nBlkX-1 && nWidth_B < nWidth) // right non-covered region
{
// luma
BitBlt(pDstCur[0] + nWidth_B, nDstPitches[0],
pSrcCur[0] + nWidth_B, nSrcPitches[0], nWidth-nWidth_B, nBlkSizeY, isse);
}
} // for bx
pDstCur[0] += ( nBlkSizeY ) * (nDstPitches[0]);
pSrcCur[0] += ( nBlkSizeY ) * (nSrcPitches[0]);
if (by == nBlkY-1 && nHeight_B < nHeight) // bottom uncovered region
{
// luma
BitBlt(pDstCur[0], nDstPitches[0], pSrcCur[0], nSrcPitches[0], nWidth, nHeight-nHeight_B, isse);
}
} // for by
} // nOverlapX==0 && nOverlapY==0
// -----------------------------------------------------------------
else // overlap
{
unsigned short *pDstShort = DstShort;
int *pDstInt = DstInt;
const int tmpPitch = nBlkSizeX;
if (lsb_flag)
{
MemZoneSet(reinterpret_cast<unsigned char*>(pDstInt), 0,
nWidth_B*4, nHeight_B, 0, 0, dstIntPitch*4);
}
else
{
MemZoneSet(reinterpret_cast<unsigned char*>(pDstShort), 0,
nWidth_B*2, nHeight_B, 0, 0, dstShortPitch*2);
}
for (int by=0; by<nBlkY; by++)
{
int wby = ((by + nBlkY - 3)/(nBlkY - 2))*3;
int xx = 0;
for (int bx=0; bx<nBlkX; bx++)
{
// select window
int wbx = (bx + nBlkX - 3)/(nBlkX - 2);
short * winOver = OverWins->GetWindow(wby + wbx);
int i = by*nBlkX + bx;
const BYTE * pB, *pF;
int npB, npF;
int WSrc, WRefB, WRefF;
use_block_y (pB , npB , WRefB , isUsableB , mvClipB , i, pPlanesB [0], pSrcCur [0], xx, nSrcPitches [0]);
use_block_y (pF , npF , WRefF , isUsableF , mvClipF , i, pPlanesF [0], pSrcCur [0], xx, nSrcPitches [0]);
norm_weights (WSrc, WRefB, WRefF);
// luma
DEGRAINLUMA(tmpBlock, tmpBlockLsb, lsb_flag, tmpPitch, pSrcCur[0]+ xx, nSrcPitches[0],
pB, npB, pF, npF, WSrc, WRefB, WRefF);
if (lsb_flag)
{
OVERSLUMALSB(pDstInt + xx, dstIntPitch, tmpBlock, tmpBlockLsb, tmpPitch, winOver, nBlkSizeX);
}
else
{
OVERSLUMA(pDstShort + xx, dstShortPitch, tmpBlock, tmpPitch, winOver, nBlkSizeX);
}
xx += (nBlkSizeX - nOverlapX);
} // for bx
pSrcCur[0] += (nBlkSizeY - nOverlapY) * (nSrcPitches[0]);
pDstShort += (nBlkSizeY - nOverlapY) * dstShortPitch;
pDstInt += (nBlkSizeY - nOverlapY) * dstIntPitch;
} // for by
if (lsb_flag)
{
Short2BytesLsb(pDst[0], pDst[0] + lsb_offset_y, nDstPitches[0], DstInt, dstIntPitch, nWidth_B, nHeight_B);
}
else
{
Short2Bytes(pDst[0], nDstPitches[0], DstShort, dstShortPitch, nWidth_B, nHeight_B);
}
if (nWidth_B < nWidth)
{
BitBlt(pDst[0] + nWidth_B, nDstPitches[0],
pSrc[0] + nWidth_B, nSrcPitches[0],
nWidth-nWidth_B, nHeight_B, isse);
}
if (nHeight_B < nHeight) // bottom noncovered region
{
BitBlt(pDst[0] + nHeight_B*nDstPitches[0], nDstPitches[0],
pSrc[0] + nHeight_B*nSrcPitches[0], nSrcPitches[0],
nWidth, nHeight-nHeight_B, isse);
}
} // overlap - end
if (nLimit < 255)
{
if (isse)
{
LimitChanges_sse2(pDst[0], nDstPitches[0], pSrc[0], nSrcPitches[0], nWidth, nHeight, nLimit);
}
else
{
LimitChanges_c(pDst[0], nDstPitches[0], pSrc[0], nSrcPitches[0], nWidth, nHeight, nLimit);
}
}
}
//----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// CHROMA plane U
process_chroma (
UPLANE & nSuperModeYUV,
pDst [1], pDstCur [1], nDstPitches [1], pSrc [1], pSrcCur [1], nSrcPitches [1],
isUsableB, isUsableF, pPlanesB [1], pPlanesF [1],
lsb_offset_u, nWidth_B, nHeight_B
);
//----------------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// CHROMA plane V
process_chroma (
VPLANE & nSuperModeYUV,
pDst [2], pDstCur [2], nDstPitches [2], pSrc [2], pSrcCur [2], nSrcPitches [2],
isUsableB, isUsableF, pPlanesB [2], pPlanesF [2],
lsb_offset_v, nWidth_B, nHeight_B
);
//--------------------------------------------------------------------------------
_mm_empty (); // (we may use double-float somewhere) Fizick
PROFILE_STOP(MOTION_PROFILE_COMPENSATION);
if ( (pixelType & VideoInfo::CS_YUY2) == VideoInfo::CS_YUY2 && !planar)
{
YUY2FromPlanes(pDstYUY2, nDstPitchYUY2, nWidth, nHeight * height_lsb_mul,
pDst[0], nDstPitches[0], pDst[1], pDst[2], nDstPitches[1], isse);
}
return dst;
}
Path& ProcessOneStepOfPath(Path& thePath, Map* map, const IntVec2& start, const IntVec2& goal, bool ignoreEntities ){
PROFILE_SECTION();
if (!thePath.m_initialized && map){
thePath = Path(map, start, goal);
}
if (!thePath.IsOpenListEmpty() && !thePath.m_isComplete){
thePath.m_iterations++;
PROFILE_START(steps 1 to 4);
//1 pick lowest f on openList check
//2 remove from open list check
PathNode* lowestFCostInThePath = thePath.PopLowestFCostInOpenList();
//3 add lowest cost to closed list check
Tile* tileToCheckID = map->GetTileAtMapPosition(lowestFCostInThePath->m_position);
tilesPathIDOpenCritSec.Enter();
tileToCheckID->m_inOpenListOfPathID = -1;
tilesPathIDOpenCritSec.Exit();
//tilesPathIDCritSec.Enter();
if (tileToCheckID->m_inClosedListOfPathID != thePath.m_id){
thePath.AddToClosedList(lowestFCostInThePath);
CRITICAL_SECTION_SCOPE(tilesPathIDClosedCritSec);
tileToCheckID->m_inClosedListOfPathID = thePath.m_id;
}
//tilesPathIDCritSec.Exit();
// if (!thePath.IsMapPositionInClosedList(lowestFCostInThePath->m_position)){
//
// thePath.AddToClosedList(lowestFCostInThePath);
//
// }
//4 set lowest f node to active
thePath.m_activeNode = lowestFCostInThePath;
PROFILE_STOP();
//5 check if node is goal, break;
if (thePath.m_activeNode->m_position == goal){
thePath.m_isComplete = true;
//ConsoleGenericMessageBox("YAY Path is found.");
thePath.m_openList.clear();
return thePath;
}
else{
TilePtrs adjacentTilePtrs;
PROFILE_START(step 6);
//6 ask "map" for adjacent positions of active node
Tile* activeTile = map->GetTileAtMapPosition(thePath.m_activeNode->m_position);
if (activeTile){
adjacentTilePtrs = map->GetValidAdjacentTiles(activeTile, ignoreEntities);
}
PROFILE_STOP();
//this is the longest part of pathing
ProcessAdjacentMapTiles(thePath, map, start, goal, adjacentTilePtrs);
}
}//end of final outer if
// else if (thePath.IsOpenListEmpty()){
// //ConsoleGenericMessageBox("No Path =(");
//
// //the path is impossible
// thePath.m_isImpossible = true;
//
// return thePath;
// }
return thePath;
}
PVideoFrame __stdcall MVRecalculate::GetFrame(int n, IScriptEnvironment* env)
{
const unsigned char *pSrcY, *pSrcU, *pSrcV;
const unsigned char *pRefY, *pRefU, *pRefV;
// const unsigned char *pSrc2xY, *pSrc2xU, *pSrc2xV;
// const unsigned char *pRef2xY, *pRef2xU, *pRef2xV;
unsigned char *pDst;
int nSrcPitchY, nSrcPitchUV;
int nRefPitchY, nRefPitchUV;
// int nSrc2xPitchY, nSrc2xPitchUV;
// int nRef2xPitchY, nRef2xPitchUV;
int minframe = ( analysisData.isBackward ) ? 0 : analysisData.nDeltaFrame;
int maxframe = ( analysisData.isBackward ) ? vi.num_frames - analysisData.nDeltaFrame : vi.num_frames;
int offset = ( analysisData.isBackward ) ? analysisData.nDeltaFrame : -analysisData.nDeltaFrame;
// DebugPrintf("MVRecalculate: Get src frame %d",n);
PVideoFrame src = child->GetFrame(n, env);
bool paritysrc = child->GetParity(n);
// PVideoFrame src2x;
// if (analysisData.usePelClip)
// src2x = pelclip->GetFrame(n, env);
PROFILE_START(MOTION_PROFILE_YUY2CONVERT);
if ( (analysisData.pixelType & VideoInfo::CS_YUY2) == VideoInfo::CS_YUY2 )
{
// planer data packed to interleaved format (same as interleved2planar by kassandro) - v2.0.0.5
pSrcY = src->GetReadPtr();
pSrcU = pSrcY + src->GetRowSize()/2;
pSrcV = pSrcU + src->GetRowSize()/4;
nSrcPitchY = src->GetPitch();
nSrcPitchUV = nSrcPitchY;
}
else
{
pSrcY = src->GetReadPtr(PLANAR_Y);
pSrcU = src->GetReadPtr(PLANAR_U);
pSrcV = src->GetReadPtr(PLANAR_V);
nSrcPitchY = src->GetPitch(PLANAR_Y);
nSrcPitchUV = src->GetPitch(PLANAR_U);
}
PROFILE_STOP(MOTION_PROFILE_YUY2CONVERT);
PVideoFrame dst;
dst = env->NewVideoFrame(vi);
pDst = dst->GetWritePtr();
// write analysis parameters as a header to frame
memcpy(pDst, &headerSize, sizeof(int));
if (divideExtra)
memcpy(pDst+sizeof(int), &analysisDataDivided, sizeof(analysisData));
else
memcpy(pDst+sizeof(int), &analysisData, sizeof(analysisData));
pDst += headerSize;
// DebugPrintf("MVRecalculate: Get ref frame %d",n + offset);
PVideoFrame mvn = mvClip.GetFrame(n, env); // get pointer to vectors
mvClip.Update(mvn, env); // force calulation of vectors
if (mvClip.IsUsable() && ( n < maxframe ) && ( n >= minframe ))
{
PVideoFrame ref = child->GetFrame(n + offset, env);
bool parityref = child->GetParity(n + offset);
// PVideoFrame ref2x;
// if (analysisData.usePelClip)
// ref2x = pelclip->GetFrame(n + offset, env);
int fieldShift = 0;
if (vi.IsFieldBased() && analysisData.nPel > 1 && (analysisData.nDeltaFrame %2 != 0))
{
fieldShift = (paritysrc && !parityref) ? analysisData.nPel/2 : ( (parityref && !paritysrc) ? -(analysisData.nPel/2) : 0);
// vertical shift of fields for fieldbased video at finest level pel2
}
PROFILE_START(MOTION_PROFILE_YUY2CONVERT);
if ( (analysisData.pixelType & VideoInfo::CS_YUY2) == VideoInfo::CS_YUY2 )
{
// planer data packed to interleaved format (same as interleved2planar by kassandro) - v2.0.0.5
pRefY = ref->GetReadPtr();
pRefU = pRefY + ref->GetRowSize()/2;
pRefV = pRefU + ref->GetRowSize()/4;
nRefPitchY = ref->GetPitch();
nRefPitchUV = nRefPitchY;
}
else
{
pRefY = ref->GetReadPtr(PLANAR_Y);
pRefU = ref->GetReadPtr(PLANAR_U);
pRefV = ref->GetReadPtr(PLANAR_V);
nRefPitchY = ref->GetPitch(PLANAR_Y);
nRefPitchUV = ref->GetPitch(PLANAR_U);
}
PROFILE_STOP(MOTION_PROFILE_YUY2CONVERT);
/*
MVFrames *pFrames = mvCore->GetFrames(analysisData.nIdx);
PROFILE_START(MOTION_PROFILE_INTERPOLATION);
PMVGroupOfFrames pSrcGOF = pFrames->GetFrame(n);
pSrcGOF->SetPlane(pSrcY, nSrcPitchY, YPLANE);
pSrcGOF->SetPlane(pSrcU, nSrcPitchUV, UPLANE);
pSrcGOF->SetPlane(pSrcV, nSrcPitchUV, VPLANE);
// pSrcGOF->Reduce(); // disabled in v1.11.02 - we use top level only here
pSrcGOF->Pad(YUVPLANES);
if (analysisData.usePelClip)
{
MVFrame *srcFrames = pSrcGOF->GetFrame(0);
MVPlane *srcPlaneY = srcFrames->GetPlane(YPLANE);
srcPlaneY->RefineExt(pSrc2xY, nSrc2xPitchY);
MVPlane *srcPlaneU = srcFrames->GetPlane(UPLANE);
srcPlaneU->RefineExt(pSrc2xU, nSrc2xPitchUV);
MVPlane *srcPlaneV = srcFrames->GetPlane(VPLANE);
srcPlaneV->RefineExt(pSrc2xV, nSrc2xPitchUV);
}
else
pSrcGOF->Refine(YUVPLANES, analysisData.sharp);
PMVGroupOfFrames pRefGOF = pFrames->GetFrame(n + offset);
pRefGOF->SetPlane(pRefY, nRefPitchY, YPLANE);
pRefGOF->SetPlane(pRefU, nRefPitchUV, UPLANE);
pRefGOF->SetPlane(pRefV, nRefPitchUV, VPLANE);
// pRefGOF->Reduce();
pRefGOF->Pad(YUVPLANES);
if (analysisData.usePelClip)
{
MVFrame *refFrames = pRefGOF->GetFrame(0);
MVPlane *refPlaneY = refFrames->GetPlane(YPLANE);
refPlaneY->RefineExt(pRef2xY, nRef2xPitchY);
MVPlane *refPlaneU = refFrames->GetPlane(UPLANE);
refPlaneU->RefineExt(pRef2xU, nRef2xPitchUV);
MVPlane *refPlaneV = refFrames->GetPlane(VPLANE);
refPlaneV->RefineExt(pRef2xV, nRef2xPitchUV);
}
else
pRefGOF->Refine(YUVPLANES, analysisData.sharp);
PROFILE_STOP(MOTION_PROFILE_INTERPOLATION);
*/
if (outfile != NULL) {
fwrite( &n, sizeof( int ), 1, outfile );// write frame number
}
pSrcGOF->Update(nModeYUV, (BYTE*)pSrcY, nSrcPitchY, (BYTE*)pSrcU, nSrcPitchUV, (BYTE*)pSrcV, nSrcPitchUV); // v2.0
pRefGOF->Update(nModeYUV, (BYTE*)pRefY, nRefPitchY, (BYTE*)pRefU, nRefPitchUV, (BYTE*)pRefV, nRefPitchUV); // v2.0
vectorFields->RecalculateMVs(mvClip, pSrcGOF, pRefGOF, searchType, nSearchParam, nLambda, lsad, pnew,
analysisData.nFlags, reinterpret_cast<int*>(pDst), outfilebuf, fieldShift, thSAD, DCTc, smooth);
if (divideExtra) {
// make extra level with divided sublocks with median (not estimated) motion
vectorFields->ExtraDivide(reinterpret_cast<int*>(pDst), analysisData.nFlags);
}
// PROFILE_CUMULATE();
if (outfile != NULL)
fwrite( outfilebuf, sizeof(short)* analysisData.nBlkX*analysisData.nBlkY*4, 1, outfile );
}
else
{
vectorFields->WriteDefaultToArray(reinterpret_cast<int*>(pDst));
}
return dst;
}