自学教程：C++ ARSAL_PRINT函数代码示例

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 JNICALLJava_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 JNICALLJava_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;    }}