int ARSTREAM2_H264_AuNaluFifoFlush(ARSTREAM2_H264_AccessUnit_t *au)
{
ARSTREAM2_H264_NaluFifoItem_t *naluItem;
if (!au)
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "Invalid pointer");
return -1;
}
while ((naluItem = ARSTREAM2_H264_AuDequeueNalu(au)) != NULL)
{
int ret = ARSTREAM2_H264_AuNaluFifoPushFreeItem(au, naluItem);
if (ret != 0)
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "Failed to push free item in the AU-NALU FIFO (%d)", ret);
}
}
return 0;
}
JNIEXPORT jint JNICALL Java_com_parrot_arsdk_ardatatransfer_ARDataTransferMediasDownloader_nativeDelete(JNIEnv *env, jobject jThis, jlong jManager)
{
ARDATATRANSFER_JNI_Manager_t *nativeJniManager = (ARDATATRANSFER_JNI_Manager_t*)(intptr_t)jManager;
ARDATATRANSFER_Manager_t *nativeManager = (nativeJniManager->nativeManager) ? nativeJniManager->nativeManager : NULL;
eARDATATRANSFER_ERROR result = ARDATATRANSFER_OK;
ARSAL_PRINT(ARSAL_PRINT_DEBUG, ARDATATRANSFER_JNI_MEDIADOWNLOADER_TAG, "");
result = ARDATATRANSFER_MediasDownloader_Delete(nativeManager);
return result;
}
ARSTREAM2_H264_AuFifoItem_t* ARSTREAM2_H264_AuFifoDuplicateItem(ARSTREAM2_H264_AuFifo_t *auFifo,
ARSTREAM2_H264_AuFifoItem_t *auItem)
{
int ret, needFree = 0;
ARSTREAM2_H264_AuFifoItem_t *auCopyItem;
if ((!auFifo) || (!auItem))
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "Invalid pointer");
return NULL;
}
auCopyItem = ARSTREAM2_H264_AuFifoPopFreeItem(auFifo);
if (auCopyItem)
{
ARSTREAM2_H264_AuCopy(&auCopyItem->au, &auItem->au);
ARSTREAM2_H264_NaluFifoItem_t *naluItem, *naluCopyItem;
for (naluItem = auItem->au.naluHead; naluItem; naluItem = naluItem->next)
{
naluCopyItem = ARSTREAM2_H264_AuNaluFifoPopFreeItem(&auCopyItem->au);
if (naluCopyItem)
{
ARSTREAM2_H264_NaluCopy(&naluCopyItem->nalu, &naluItem->nalu);
ret = ARSTREAM2_H264_AuEnqueueNalu(&auCopyItem->au, naluCopyItem);
if (ret != 0)
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "Failed to enqueue NALU item in AU");
ret = ARSTREAM2_H264_AuNaluFifoPushFreeItem(&auCopyItem->au, naluCopyItem);
if (ret != 0)
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "Failed to push free FIFO item");
}
needFree = 1;
}
}
else
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "Failed to pop free item from the NALU FIFO");
needFree = 1;
}
}
}
else
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "Failed to pop free item from the AU FIFO");
}
if (needFree)
{
ret = ARSTREAM2_H264_AuFifoPushFreeItem(auFifo, auCopyItem);
if (ret != 0)
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "Failed to push free item in the AU FIFO (%d)", ret);
}
needFree = 0;
auCopyItem = NULL;
}
return auCopyItem;
}
JNIEXPORT jint JNICALL Java_com_parrot_arsdk_arsal_ARSALMd5Manager_nativeCheck(JNIEnv *env, jobject jThis, jlong jManager, jstring jFilePath, jstring jMd5Txt)
{
ARSAL_MD5_Manager_t *nativeManager = (ARSAL_MD5_Manager_t*) (intptr_t) jManager;
const char *nativeFilePath = NULL;
const char *nativeMd5Txt = NULL;
eARSAL_ERROR result = ARSAL_OK;
ARSAL_PRINT(ARSAL_PRINT_DEBUG, ARSAL_JNI_MD5_MANAGER_TAG, "%d", (int)nativeManager);
if ((nativeManager == NULL) || (nativeManager->md5Check == NULL))
{
result = ARSAL_ERROR_BAD_PARAMETER;
}
if (result == ARSAL_OK)
{
nativeFilePath = (*env)->GetStringUTFChars(env, jFilePath, 0);
if (nativeFilePath == NULL)
{
result = ARSAL_ERROR_ALLOC;
}
}
if (result == ARSAL_OK)
{
nativeMd5Txt = (*env)->GetStringUTFChars(env, jMd5Txt, 0);
if (nativeMd5Txt == NULL)
{
result = ARSAL_ERROR_ALLOC;
}
}
//ARSAL_PRINT(ARSAL_PRINT_DEBUG, ARSAL_JNI_MD5_MANAGER_TAG, "%d, %s, %s", result, nativeFilePath, nativeMd5Txt);
if (result == ARSAL_OK)
{
result = nativeManager->md5Check(nativeManager->md5Object, nativeFilePath, nativeMd5Txt);
}
if (nativeFilePath != NULL)
{
(*env)->ReleaseStringUTFChars(env, jFilePath, nativeFilePath);
}
if (nativeMd5Txt != NULL)
{
(*env)->ReleaseStringUTFChars(env, jMd5Txt, nativeMd5Txt);
}
return result;
}
int ARSTREAM2_H264_AuNaluFifoFree(ARSTREAM2_H264_AccessUnit_t *au)
{
if (!au)
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "Invalid pointer");
return -1;
}
free(au->naluPool);
memset(au, 0, sizeof(ARSTREAM2_H264_AccessUnit_t));
return 0;
}
uint16_t ARDISCOVERY_getProductID(eARDISCOVERY_PRODUCT product)
{
if (product < ARDISCOVERY_PRODUCT_MAX)
{
return ARDISCOVERY_Discovery_ProductTable[product];
}
else
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARDISCOVERY_DISCOVERY_TAG,
"Unknown product : %d", product);
return 0;
}
}
uint8_t* ARSTREAM_ReaderTb_FrameCompleteCallback (eARSTREAM_READER_CAUSE cause, uint8_t *framePointer, uint32_t frameSize, int numberOfSkippedFrames, int isFlushFrame, uint32_t *newBufferCapacity, void *buffer)
{
uint8_t *retVal = NULL;
struct timespec now;
int dt;
buffer = buffer;
switch (cause)
{
case ARSTREAM_READER_CAUSE_FRAME_COMPLETE:
case ARSTREAM_READER_CAUSE_FRAME_INCOMPLETE:
ARSAL_PRINT (ARSAL_PRINT_WARNING, __TAG__, "Got a frame of size %d, at address %p (isFlush : %d)", frameSize, framePointer, isFlushFrame);
if (isFlushFrame != 0)
nbRead++;
if (numberOfSkippedFrames != 0)
{
ARSAL_PRINT (ARSAL_PRINT_WARNING, __TAG__, "Skipped %d frames", numberOfSkippedFrames);
if (numberOfSkippedFrames > 0)
{
nbSkipped += numberOfSkippedFrames;
nbSkippedSinceLast += numberOfSkippedFrames;
}
}
ARSTREAM_Reader_PercentOk = (100.f * nbRead) / (1.f * (nbRead + nbSkipped));
if (outFile != NULL)
{
fwrite (framePointer, 1, frameSize, outFile);
}
ARSAL_Time_GetTime(&now);
dt = ARSAL_Time_ComputeTimespecMsTimeDiff(&lastRecv, &now);
lastDt [currentIndexInDt] = dt;
currentIndexInDt ++;
currentIndexInDt %= NB_FRAMES_FOR_AVERAGE;
lastRecv.tv_sec = now.tv_sec;
lastRecv.tv_nsec = now.tv_nsec;
ARSTREAM_ReaderTb_SetBufferFree (framePointer);
retVal = ARSTREAM_ReaderTb_GetNextFreeBuffer (newBufferCapacity, 0);
break;
case ARSTREAM_READER_CAUSE_FRAME_TOO_SMALL:
ARSAL_PRINT (ARSAL_PRINT_WARNING, __TAG__, "Current buffer is to small for frame !");
retVal = ARSTREAM_ReaderTb_GetNextFreeBuffer (newBufferCapacity, 1);
break;
case ARSTREAM_READER_CAUSE_COPY_COMPLETE:
ARSAL_PRINT (ARSAL_PRINT_WARNING, __TAG__, "Copy complete in new buffer, freeing this one");
ARSTREAM_ReaderTb_SetBufferFree (framePointer);
break;
case ARSTREAM_READER_CAUSE_CANCEL:
ARSAL_PRINT (ARSAL_PRINT_WARNING, __TAG__, "Reader is closing");
ARSTREAM_ReaderTb_SetBufferFree (framePointer);
break;
default:
ARSAL_PRINT (ARSAL_PRINT_ERROR, __TAG__, "Unknown cause (probably a bug !)");
break;
}
return retVal;
}
JNIEXPORT jlong JNICALL
Java_com_parrot_arsdk_arstream_ARStreamReader_nativeConstructor (JNIEnv *env, jobject thizz, jlong cNetManager, jint dataBufferId, jint ackBufferId, jlong frameBuffer, jint frameBufferSize, jint maxFragmentSize, jint maxAckInterval)
{
eARSTREAM_ERROR err = ARSTREAM_OK;
jobject g_thizz = (*env)->NewGlobalRef(env, thizz);
ARSTREAM_Reader_t *retReader = ARSTREAM_Reader_New ((ARNETWORK_Manager_t *)(intptr_t)cNetManager, dataBufferId, ackBufferId, internalCallback, (uint8_t *)(intptr_t)frameBuffer, frameBufferSize, maxFragmentSize, maxAckInterval, (void *)g_thizz, &err);
if (err != ARSTREAM_OK)
{
ARSAL_PRINT (ARSAL_PRINT_ERROR, JNI_READER_TAG, "Error while creating reader : %s", ARSTREAM_Error_ToString (err));
}
return (jlong)(intptr_t)retReader;
}
int ARSTREAM2_H264_NaluFifoEnqueueItem(ARSTREAM2_H264_NaluFifo_t *fifo, ARSTREAM2_H264_NaluFifoItem_t *item)
{
if ((!fifo) || (!item))
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "Invalid pointer");
return -1;
}
ARSAL_Mutex_Lock(&(fifo->mutex));
if (fifo->count >= fifo->size)
{
ARSAL_Mutex_Unlock(&(fifo->mutex));
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "NALU FIFO is full");
return -2;
}
item->next = NULL;
if (fifo->tail)
{
fifo->tail->next = item;
item->prev = fifo->tail;
}
else
{
item->prev = NULL;
}
fifo->tail = item;
if (!fifo->head)
{
fifo->head = item;
}
fifo->count++;
ARSAL_Mutex_Unlock(&(fifo->mutex));
return 0;
}
int ARSTREAM2_H264_AuFifoUnrefBuffer(ARSTREAM2_H264_AuFifo_t *fifo, ARSTREAM2_H264_AuFifoBuffer_t *buffer)
{
if ((!fifo) || (!buffer))
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "Invalid pointer");
return -1;
}
ARSAL_Mutex_Lock(&(fifo->mutex));
if (buffer->refCount != 0)
{
buffer->refCount--;
}
else
{
ARSAL_PRINT(ARSAL_PRINT_WARNING, ARSTREAM2_H264_TAG, "FIXME! Ref count is already null, this should not happen!");
}
if (buffer->refCount == 0)
{
if (fifo->bufferFree)
{
fifo->bufferFree->prev = buffer;
buffer->next = fifo->bufferFree;
}
else
{
buffer->next = NULL;
}
fifo->bufferFree = buffer;
buffer->prev = NULL;
}
ARSAL_Mutex_Unlock(&(fifo->mutex));
return 0;
}
int ARSTREAM2_H264_NaluFifoFree(ARSTREAM2_H264_NaluFifo_t *fifo)
{
if (!fifo)
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "Invalid pointer");
return -1;
}
ARSAL_Mutex_Destroy(&(fifo->mutex));
free(fifo->pool);
memset(fifo, 0, sizeof(ARSTREAM2_H264_NaluFifo_t));
return 0;
}
ARSTREAM2_H264_NaluFifoItem_t* ARSTREAM2_H264_AuNaluFifoPopFreeItem(ARSTREAM2_H264_AccessUnit_t *au)
{
if (!au)
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "Invalid pointer");
return NULL;
}
if (au->naluFree)
{
ARSTREAM2_H264_NaluFifoItem_t* cur = au->naluFree;
au->naluFree = cur->next;
if (cur->next) cur->next->prev = NULL;
cur->prev = NULL;
cur->next = NULL;
return cur;
}
else
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "AU-NALU FIFO is full");
return NULL;
}
}
void ARNETWORK_Sender_SendPong (ARNETWORK_Sender_t *senderPtr, uint8_t *data, int dataSize)
{
ARNETWORK_IOBuffer_t *inputBufferPtrTemp;
eARNETWORK_ERROR err = ARNETWORK_OK;
inputBufferPtrTemp = senderPtr->inputBufferPtrMap[ARNETWORK_MANAGER_INTERNAL_BUFFER_ID_PONG];
err = ARNETWORK_IOBuffer_Lock (inputBufferPtrTemp);
if (err != ARNETWORK_OK) {
ARSAL_PRINT (ARSAL_PRINT_ERROR, ARNETWORK_SENDER_TAG, "ARNETWORK_IOBuffer_Lock() failed; error: %s", ARNETWORK_Error_ToString (err));
return;
}
ARNETWORK_IOBuffer_AddData (inputBufferPtrTemp, data, dataSize, NULL, NULL, 1);
ARNETWORK_IOBuffer_Unlock (inputBufferPtrTemp);
}
void ARUTILS_Manager_Delete(ARUTILS_Manager_t **managerAddr)
{
ARSAL_PRINT(ARSAL_PRINT_DEBUG, ARUTILS_MANAGER_TAG, "");
if (managerAddr != NULL)
{
ARUTILS_Manager_t *manager = *managerAddr;
if (manager != NULL)
{
free(manager);
}
*managerAddr = NULL;
}
}
JNIEXPORT jint JNICALL Java_com_parrot_arsdk_arsal_ARSALMd5Manager_nativeClose(JNIEnv *env, jobject jThis, jlong jManager)
{
ARSAL_MD5_Manager_t *nativeManager = (ARSAL_MD5_Manager_t*) (intptr_t) jManager;
eARSAL_ERROR result = ARSAL_OK;
ARSAL_PRINT(ARSAL_PRINT_DEBUG, ARSAL_JNI_MD5_MANAGER_TAG, "");
if (nativeManager->md5Object != NULL)
{
(*env)->DeleteGlobalRef(env, (jobject)nativeManager->md5Object);
nativeManager->md5Object = NULL;
}
return result;
}
int ARSTREAM2_H264_AuFifoFlushQueue(ARSTREAM2_H264_AuFifo_t *fifo, ARSTREAM2_H264_AuFifoQueue_t *queue)
{
ARSTREAM2_H264_AuFifoItem_t* item;
int count = 0, fifoErr;
if ((!fifo) || (!queue))
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "Invalid pointer");
return -1;
}
do
{
item = ARSTREAM2_H264_AuFifoDequeueItem(queue);
if (item)
{
if (item->au.buffer)
{
fifoErr = ARSTREAM2_H264_AuFifoUnrefBuffer(fifo, item->au.buffer);
if (fifoErr != 0)
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "ARSTREAM2_H264_AuFifoUnrefBuffer() failed (%d)", fifoErr);
}
}
fifoErr = ARSTREAM2_H264_AuFifoPushFreeItem(fifo, item);
if (fifoErr != 0)
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "ARSTREAM2_H264_AuFifoPushFreeItem() failed (%d)", fifoErr);
}
count++;
}
}
while (item);
return count;
}
//this function is called when the state of the device controller has changed:
void stateChanged(eARCONTROLLER_DEVICE_STATE newState,
eARCONTROLLER_ERROR error, void *customData) {
ARSAL_PRINT(ARSAL_PRINT_INFO, TAG, "-stateChanged newState: %d .....",newState);
switch (newState) {
case ARCONTROLLER_DEVICE_STATE_STOPPED:
ARSAL_Sem_Post(&(stateSem));
gIHMRun = 0;
break;
case ARCONTROLLER_DEVICE_STATE_RUNNING:
ARSAL_Sem_Post(&(stateSem));
break;
default:
break;
}
}
eARUTILS_ERROR ARUTILS_Manager_Ftp_Connection_IsCanceled(ARUTILS_Manager_t *manager)
{
eARUTILS_ERROR result = ARUTILS_OK;
if ((manager == NULL) || (manager->ftpConnectionIsCanceled == NULL))
{
ARSAL_PRINT(ARSAL_PRINT_DEBUG, ARUTILS_MANAGER_TAG, "%p, %p", manager, manager->ftpConnectionIsCanceled);
result = ARUTILS_ERROR_BAD_PARAMETER;
}
else
{
result = manager->ftpConnectionIsCanceled(manager);
}
return result;
}
eARNETWORK_MANAGER_CALLBACK_RETURN arnetworkCmdCallback(int buffer_id, uint8_t *data, void *custom, eARNETWORK_MANAGER_CALLBACK_STATUS cause)
{
printf(" ARNETWORK_MANAGER_CALLBACK_RETURN_DEFAULT\n");
eARNETWORK_MANAGER_CALLBACK_RETURN retval = ARNETWORK_MANAGER_CALLBACK_RETURN_DEFAULT;
ARSAL_PRINT(ARSAL_PRINT_DEBUG, TAG, " - arnetworkCmdCallback %d, cause:%d ", buffer_id, cause);
if (cause == ARNETWORK_MANAGER_CALLBACK_STATUS_TIMEOUT)
{
printf(" ARNETWORK_MANAGER_CALLBACK_Status_Timeout\n");
retval = ARNETWORK_MANAGER_CALLBACK_RETURN_DATA_POP;
}
return retval;
}
JNIEXPORT void JNICALL
Java_com_parrot_arsdk_armavlink_ARMavlinkFileParser_nativeParse (JNIEnv *env, jobject obj, jlong fileParserPtr, jstring path, jlong missionListPtr)
{
ARMAVLINK_FileParser_t *nativeFileParser = (ARMAVLINK_FileParser_t*) (intptr_t) fileParserPtr;
mission_item_list_t *nativeMissionList = (mission_item_list_t*) (intptr_t) missionListPtr;
const char *filePath = (*env)->GetStringUTFChars(env, path, 0);
eARMAVLINK_ERROR result = ARMAVLINK_FileParser_Parse(nativeFileParser, filePath, nativeMissionList);
if (result != ARMAVLINK_OK)
{
ARSAL_PRINT (ARSAL_PRINT_DEBUG, ARMAVLINK_JNIMAVLINK_TAG, "error: %d occurred", result);
Throw_Mavlink_Exception(env, result);
}
}
void ARDATATRANSFER_JNI_Manager_FreeERROR_ENUM_JNI(JNIEnv *env)
{
ARSAL_PRINT(ARSAL_PRINT_DEBUG, ARDATATRANSFER_JNI_MANAGER_TAG, "");
if (env != NULL)
{
if (classDTERROR_ENUM != NULL)
{
(*env)->DeleteGlobalRef(env, classDTERROR_ENUM);
classDTERROR_ENUM = NULL;
}
methodId_DTERROR_ENUM_getFromValue = NULL;
}
}
void ARDATATRANSFER_JNI_Manager_FreeARDataTransferExceptionJNI(JNIEnv *env)
{
ARSAL_PRINT(ARSAL_PRINT_DEBUG, ARDATATRANSFER_JNI_MANAGER_TAG, "");
if (env != NULL)
{
if (classDTException != NULL)
{
(*env)->DeleteGlobalRef(env, classDTException);
classDTException = NULL;
}
methodId_DTException_Init = NULL;
}
}
int ARSTREAM_ReaderTb_StartStreamTest (ARNETWORK_Manager_t *manager, const char *outPath)
{
int retVal = 0;
uint8_t *firstFrame;
uint32_t firstFrameSize;
eARSTREAM_ERROR err;
if (NULL != outPath)
{
outFile = fopen (outPath, "wb");
}
else
{
outFile = NULL;
}
ARSTREAM_ReaderTb_initMultiBuffers (FRAME_MAX_SIZE);
ARSAL_Sem_Init (&closeSem, 0, 0);
firstFrame = ARSTREAM_ReaderTb_GetNextFreeBuffer (&firstFrameSize, 0);
g_Reader = ARSTREAM_Reader_New (manager, DATA_BUFFER_ID, ACK_BUFFER_ID, ARSTREAM_ReaderTb_FrameCompleteCallback, firstFrame, firstFrameSize, ARSTREAM_TB_FRAG_SIZE, 0, NULL, &err);
if (g_Reader == NULL)
{
ARSAL_PRINT (ARSAL_PRINT_ERROR, __TAG__, "Error during ARSTREAM_Reader_New call : %s", ARSTREAM_Error_ToString(err));
return 1;
}
pthread_t streamsend, streamread;
pthread_create (&streamsend, NULL, ARSTREAM_Reader_RunDataThread, g_Reader);
pthread_create (&streamread, NULL, ARSTREAM_Reader_RunAckThread, g_Reader);
/* USER CODE */
running = 1;
ARSAL_Sem_Wait (&closeSem);
running = 0;
/* END OF USER CODE */
ARSTREAM_Reader_StopReader (g_Reader);
pthread_join (streamread, NULL);
pthread_join (streamsend, NULL);
ARSTREAM_Reader_Delete (&g_Reader);
ARSAL_Sem_Destroy (&closeSem);
return retVal;
}
eARDATATRANSFER_ERROR ARDATATRANSFER_Downloader_New (ARDATATRANSFER_Manager_t *manager, ARUTILS_Manager_t *ftpManager, const char *remotePath, const char *localPath, ARDATATRANSFER_Downloader_ProgressCallback_t progressCallback, void *progressArg, ARDATATRANSFER_Downloader_CompletionCallback_t completionCallback, void *completionArg, eARDATATRANSFER_DOWNLOADER_RESUME resume)
{
eARDATATRANSFER_ERROR result = ARDATATRANSFER_OK;
//eARUTILS_ERROR resultUtil = ARUTILS_OK;
ARSAL_PRINT(ARSAL_PRINT_DEBUG, ARDATATRANSFER_DATA_UPLOADER_TAG, "");
if ((manager == NULL) || (ftpManager == NULL))
{
result = ARDATATRANSFER_ERROR_BAD_PARAMETER;
}
if (result == ARDATATRANSFER_OK)
{
if (manager->downloader != NULL)
{
result = ARDATATRANSFER_ERROR_ALREADY_INITIALIZED;
}
else
{
manager->downloader = (ARDATATRANSFER_Downloader_t *)calloc(1, sizeof(ARDATATRANSFER_Downloader_t));
if (manager->downloader == NULL)
{
result = ARDATATRANSFER_ERROR_ALLOC;
}
}
}
if (result == ARDATATRANSFER_OK)
{
manager->downloader->resume = resume;
manager->downloader->ftpManager = ftpManager;
strncpy(manager->downloader->remotePath, remotePath, ARUTILS_FTP_MAX_PATH_SIZE);
manager->downloader->remotePath[ARUTILS_FTP_MAX_PATH_SIZE - 1] = '\0';
strncpy(manager->downloader->localPath, localPath, ARUTILS_FTP_MAX_PATH_SIZE);
manager->downloader->localPath[ARUTILS_FTP_MAX_PATH_SIZE - 1] = '\0';
manager->downloader->progressCallback = progressCallback;
manager->downloader->progressArg = progressArg;
manager->downloader->completionCallback = completionCallback;
manager->downloader->completionArg = completionArg;
}
return result;
}
JNIEXPORT jint JNICALL Java_com_parrot_arsdk_ardatatransfer_ARDataTransferDownloader_nativeNew(JNIEnv *env, jobject jThis, jlong jManager, jlong jFtpManager, jstring jRemotePath, jstring jLocalPath, jobject jProgressListener, jobject jProgressArg, jobject jCompletionListener, jobject jCompletionArg, jint jResume)
{
ARDATATRANSFER_JNI_Manager_t *nativeJniManager = (ARDATATRANSFER_JNI_Manager_t*)(intptr_t)jManager;
ARDATATRANSFER_Manager_t *nativeManager = (nativeJniManager->nativeManager) ? nativeJniManager->nativeManager : NULL;
ARUTILS_Manager_t *nativeFtpManager = (ARUTILS_Manager_t *)(intptr_t)jFtpManager;
ARDATATRANSFER_JNI_DownloaderCallbacks_t *callbacks = NULL;
const char *nativeRemotePath = (*env)->GetStringUTFChars(env, jRemotePath, 0);
const char *nativeLocalPath = (*env)->GetStringUTFChars(env, jLocalPath, 0);
eARDATATRANSFER_ERROR result = ARDATATRANSFER_OK;
int error = JNI_OK;
ARSAL_PRINT(ARSAL_PRINT_DEBUG, ARDATATRANSFER_JNI_DOWNLOADER_TAG, "%s, %s", nativeRemotePath ? nativeRemotePath : "null", nativeLocalPath ? nativeLocalPath : "null");
error = ARDATATRANSFER_JNI_Downloader_NewListenersJNI(env);
if (error == JNI_OK)
{
error = ARDATATRANSFER_JNI_Downloader_NewDownloaderCallbacks(env, &callbacks, jProgressListener, jProgressArg, jCompletionListener, jCompletionArg);
}
if (error != JNI_OK)
{
result = ARDATATRANSFER_ERROR_ALLOC;
}
if (result == ARDATATRANSFER_OK)
{
result = ARDATATRANSFER_Downloader_New(nativeManager, nativeFtpManager, nativeRemotePath, nativeLocalPath, ARDATATRANSFER_JNI_Downloader_ProgressCallback, callbacks, ARDATATRANSFER_JNI_Downloader_CompletionCallback, callbacks, jResume);
}
//cleanup
if (error != JNI_OK)
{
ARDATATRANSFER_JNI_Downloader_FreeDownloaderCallbacks(env, &callbacks);
}
if (nativeRemotePath != NULL)
{
(*env)->ReleaseStringUTFChars(env, jRemotePath, nativeRemotePath);
}
if (nativeLocalPath != NULL)
{
(*env)->ReleaseStringUTFChars(env, jLocalPath, nativeLocalPath);
}
return result;
}
eARNETWORK_ERROR ARNETWORK_Receiver_CopyDataRecv (ARNETWORK_Receiver_t *receiverPtr, ARNETWORK_IOBuffer_t *outputBufferPtr, ARNETWORKAL_Frame_t *framePtr)
{
/** -- copy the data received to the output buffer -- */
/** local declarations */
eARNETWORK_ERROR error = ARNETWORK_OK;
int semError = 0;
int dataSize = 0;
int nbNew = ARNETWORK_IOBuffer_ShouldAcceptData (outputBufferPtr, framePtr->seq);
/** get the data size*/
dataSize = framePtr->size - offsetof (ARNETWORKAL_Frame_t, dataPtr);
/** if the output buffer can copy the data */
if (ARNETWORK_IOBuffer_CanCopyData (outputBufferPtr))
{
/** copy the data in the IOBuffer */
error = ARNETWORK_IOBuffer_AddData (outputBufferPtr, framePtr->dataPtr, dataSize, NULL, NULL, 1);
}
else
{
error = ARNETWORK_ERROR_BAD_PARAMETER;
ARSAL_PRINT (ARSAL_PRINT_ERROR, ARNETWORK_RECEIVER_TAG, "[%p] Error: output buffer can't copy data", receiverPtr);
}
if (error == ARNETWORK_OK)
{
/** Keep buffer "miss count" accurate */
outputBufferPtr->nbPackets++;
outputBufferPtr->nbNetwork += nbNew;
outputBufferPtr->seq = framePtr->seq;
/** post a semaphore to indicate data ready to be read */
semError = ARSAL_Sem_Post (&(outputBufferPtr->outputSem));
if (semError)
{
error = ARNETWORK_ERROR_SEMAPHORE;
}
#ifdef ENABLE_MONITOR_INCOMING_DATA
/* write 1 in eventfd to wake up consumer */
error = ARNETWORK_Receiver_WriteEventFd(receiverPtr, 1);
#endif
}
return error;
}
int ARSTREAM2_H264_AuFifoBufferAddRef(ARSTREAM2_H264_AuFifo_t *fifo, ARSTREAM2_H264_AuFifoBuffer_t *buffer)
{
if (!buffer)
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARSTREAM2_H264_TAG, "Invalid pointer");
return -1;
}
ARSAL_Mutex_Lock(&(fifo->mutex));
buffer->refCount++;
ARSAL_Mutex_Unlock(&(fifo->mutex));
return 0;
}
ARUTILS_Manager_t* ARUTILS_Manager_New(eARUTILS_ERROR *error)
{
ARUTILS_Manager_t *newManager = NULL;
eARUTILS_ERROR result = ARUTILS_OK;
ARSAL_PRINT(ARSAL_PRINT_DEBUG, ARUTILS_MANAGER_TAG, "");
newManager = calloc(1, sizeof(ARUTILS_Manager_t));
if (newManager == NULL)
{
result = ARUTILS_ERROR_ALLOC;
}
*error = result;
return newManager;
}
const char* ARDISCOVERY_getProductName(eARDISCOVERY_PRODUCT product)
{
char *name = NULL;
if(product < ARDISCOVERY_PRODUCT_MAX)
{
name = (char *)ARDISCOVERY_Discovery_ProductNameTable[product];
}
else
{
ARSAL_PRINT(ARSAL_PRINT_ERROR, ARDISCOVERY_DISCOVERY_TAG,
"Unknown product : %d", product);
name = "UNKNOWN";
}
return (const char *)name;
}
/**
* @brief Delete an Ftp Connection
* @warning This function frees memory
* @param connection The address of the pointer on the Ftp Connection
* @see ARUTILS_FtpAL_NewConnection ()
*/
void ARUTILS_BLEFtp_Connection_Delete(ARUTILS_BLEFtp_Connection_t **connectionAddr)
{
eARUTILS_ERROR error = ARUTILS_OK;
/* local declarations */
JNIEnv *env = NULL;
jint getEnvResult = JNI_OK;
/* Check parameters */
/**/
/* get the environment */
if (ARUTILS_JNI_Manager_VM != NULL)
{
getEnvResult = (*ARUTILS_JNI_Manager_VM)->GetEnv(ARUTILS_JNI_Manager_VM, (void **) &env, JNI_VERSION_1_6);
}
/* if no environment then attach the thread to the virtual machine */
if (getEnvResult == JNI_EDETACHED)
{
ARSAL_PRINT(ARSAL_PRINT_DEBUG, ARUTILS_JNI_BLEFTP_TAG, "attach the thread to the virtual machine ...");
(*ARUTILS_JNI_Manager_VM)->AttachCurrentThread(ARUTILS_JNI_Manager_VM, &env, NULL);
}
/* check the environment */
if (env == NULL)
{
error = ARUTILS_ERROR;
}
if ((error == ARUTILS_OK) && (connectionAddr != NULL))
{
ARUTILS_BLEFtp_Connection_t *connection = *connectionAddr;
if (connection != NULL)
{
// bleFTP java unregisterCharacteristics
(*env)->DeleteGlobalRef (env, connection->bleFtpObject);
(*env)->DeleteGlobalRef (env, connection->cancelSemObject);
connection->bleFtpObject = NULL;
connection->cancelSemObject = NULL;
free(connection);
}
*connectionAddr = NULL;
}
}
