void stream_deinit(struct _libstream_stream* stream) {
stream_close(stream);
sem_destroy(&stream->download);
curl_easy_cleanup(stream->handle);
queue_deinit(&stream->buffer);
return;
}
/*!
* Deinitializes a subject.
*
* \param this_ptr - A pointer to the subject.
*/
void subject_deinit(subject_t *this_ptr)
{
if (this_ptr != NULL) {
queue_deinit(&this_ptr->queue);
observer_deinit(&this_ptr->observer);
}
}
int server(int initfd) {
// Create the shared queue
queue_t q;
int res;
queue_init(&q, QUEUE_SIZE);
// Create the consumer threads
pthread_t cthreads[CONSUMERS_COUNT];
unsigned i;
for (i = 0; i < CONSUMERS_COUNT; i++) {
res = pthread_create(&cthreads[i], NULL, &consumer_thread, &q);
assert(res == 0);
}
// Create the listening socket
int accsock = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
assert(accsock >= 0);
int true = 1;
res = setsockopt(accsock, SOL_SOCKET, SO_REUSEADDR, &true, sizeof(true));
assert(res == 0);
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
addr.sin_port = htons(LISTEN_PORT);
res = bind(accsock, (struct sockaddr*)&addr, sizeof(addr));
assert(res == 0);
res = listen(accsock, BACKLOG_SIZE);
assert(res == 0);
close(initfd);
fprintf(stderr, "Server initialized\n");
serve(&q, accsock);
for (i = 0; i < CONSUMERS_COUNT; i++) {
res = pthread_join(cthreads[i], NULL);
assert(res == 0);
}
queue_deinit(&q);
return 0;
}
static void ts_buf_deinit(void)
{
queue_deinit(&tsp_pool_cb);
queue_deinit(&tsp_queue_cb);
}
uint32_t stream_init(struct _libstream_stream *stream, const char* url,
uint32_t bufsize) {
int ret;
memset(stream, 0, sizeof(struct _libstream_stream));
stream->url = url;
// Create FIFO queue.
#ifdef DEBUG
assert(bufsize > BUFSIZE_MIN);
#endif
ret = queue_init(&stream->buffer, bufsize);
if (ret == false) {
ret = LIBSTREAM_MEMORY;
goto _stream_init_err0;
}
// Set up curl handles.
stream->handle = curl_easy_init();
if (stream->handle == NULL) {
ret = LIBSTREAM_INTERNAL;
goto _stream_init_err1;
}
// Set the fixed options.
// User config handled in _stream_setopt.
#ifdef DEBUG
ret = curl_easy_setopt(stream->handle, CURLOPT_ERRORBUFFER,
stream->error_);
if (ret != CURLE_OK) {
ret = LIBSTREAM_CURL_ERR(ret);
goto _stream_init_err2;
}
#endif
ret = curl_easy_setopt(stream->handle, CURLOPT_URL, url);
if (ret != CURLE_OK) {
ret = LIBSTREAM_CURL_ERR(ret);
goto _stream_init_err2;
}
ret = curl_easy_setopt(stream->handle, CURLOPT_WRITEFUNCTION,
_libstream_bgstream_write);
if (ret != CURLE_OK) {
ret = LIBSTREAM_CURL_ERR(ret);
goto _stream_init_err2;
}
ret = curl_easy_setopt(stream->handle, CURLOPT_WRITEDATA, stream);
if (ret != CURLE_OK) {
ret = LIBSTREAM_CURL_ERR(ret);
goto _stream_init_err2;
}
// Set up and run background thread.
stream->running = 0;
stream->err = LIBSTREAM_INTERNAL;
// Initialize the semaphore to 0 to block the new thread immediately.
ret = sem_init(&stream->download, false, 0);
if (ret < 0) {
ret = LIBSTREAM_INTERNAL;
goto _stream_init_err2;
}
if (pthread_create(&stream->bg_thread, NULL,
&_libstream_bgstream_main, stream) != 0) {
ret = LIBSTREAM_INTERNAL;
goto _stream_init_err2;
}
while(!stream->running) {
pthread_yield();
}
sem_post(&stream->download);
return LIBSTREAM_OK;
// Error handling.
_stream_init_err2:
curl_easy_cleanup(stream->handle);
_stream_init_err1:
queue_deinit(&stream->buffer);
_stream_init_err0:
return ret;
}
void atwilc_debugfs_remove(void)
{
queue_deinit(&g_dumpqueue);
debugfs_remove_recursive(atwilc_dir);
}
OMX_ERRORTYPE camera_video_port_Destructor(omx_base_PortType *openmaxStandPort)
{
omx_base_camera_video_PortType *omx_base_filter_Private;
omx_base_filter_Private = (omx_base_camera_video_PortType *)openmaxStandPort;
#ifndef _OPENMAX_V1_2_
if(openmaxStandPort->sPortParam.format.image.cMIMEType)
{
free(openmaxStandPort->sPortParam.format.image.cMIMEType);
openmaxStandPort->sPortParam.format.image.cMIMEType = NULL;
}
if(openmaxStandPort->sPortParam.format.video.cMIMEType)
{
free(openmaxStandPort->sPortParam.format.video.cMIMEType);
openmaxStandPort->sPortParam.format.video.cMIMEType = NULL;
}
#endif
if(omx_base_filter_Private->pAFStatusL)
{
free(omx_base_filter_Private->pAFStatusL);
omx_base_filter_Private->pAFStatusL = NULL;
}
if(omx_base_filter_Private->pHdrParam)
{
free(omx_base_filter_Private->pHdrParam);
omx_base_filter_Private->pHdrParam = NULL;
}
if(omx_base_filter_Private->pAFRegionL)
{
free(omx_base_filter_Private->pAFRegionL);
omx_base_filter_Private->pAFRegionL = NULL;
}
if(omx_base_filter_Private->pAFStatus)
{
free(omx_base_filter_Private->pAFStatus);
omx_base_filter_Private->pAFStatus = NULL;
}
if(omx_base_filter_Private->pAFRegion)
{
free(omx_base_filter_Private->pAFRegion);
omx_base_filter_Private->pAFRegion = NULL;
}
if(omx_base_filter_Private->pExpVal)
{
free(omx_base_filter_Private->pExpVal);
omx_base_filter_Private->pExpVal = NULL;
}
if(omx_base_filter_Private->pSat)
{
free(omx_base_filter_Private->pSat);
omx_base_filter_Private->pSat = NULL;
}
if(omx_base_filter_Private->pBright)
{
free(omx_base_filter_Private->pBright);
omx_base_filter_Private->pBright = NULL;
}
if(omx_base_filter_Private->act_agc)
{
free(omx_base_filter_Private->act_agc);
omx_base_filter_Private->act_agc = NULL;
}
if(omx_base_filter_Private->act_flashstrobe)
{
free(omx_base_filter_Private->act_flashstrobe);
omx_base_filter_Private->act_flashstrobe = NULL;
}
if(omx_base_filter_Private->pContrast)
{
free(omx_base_filter_Private->pContrast);
omx_base_filter_Private->pContrast = NULL;
}
if(omx_base_filter_Private->pExpType)
{
free(omx_base_filter_Private->pExpType);
omx_base_filter_Private->pExpType = NULL;
}
if(omx_base_filter_Private->pWBType)
{
free(omx_base_filter_Private->pWBType);
omx_base_filter_Private->pWBType = NULL;
}
if(omx_base_filter_Private->pOpticZoomType)
{
free(omx_base_filter_Private->pOpticZoomType);
omx_base_filter_Private->pOpticZoomType = NULL;
}
if(omx_base_filter_Private->pImageMirror)
{
free(omx_base_filter_Private->pImageMirror);
omx_base_filter_Private->pImageMirror = NULL;
}
if(omx_base_filter_Private->pImageFilter)
{
free(omx_base_filter_Private->pImageFilter);
omx_base_filter_Private->pImageFilter = NULL;
}
if(omx_base_filter_Private->pColorFix)
{
free(omx_base_filter_Private->pColorFix);
omx_base_filter_Private->pColorFix = NULL;
}
if(omx_base_filter_Private->pColorEft)
{
free(omx_base_filter_Private->pColorEft);
omx_base_filter_Private->pColorEft = NULL;
}
if(omx_base_filter_Private->pSensorMode)
{
free(omx_base_filter_Private->pSensorMode);
omx_base_filter_Private->pSensorMode = NULL;
}
if(omx_base_filter_Private->pFocusType)
{
free(omx_base_filter_Private->pFocusType);
omx_base_filter_Private->pFocusType = NULL;
}
if(omx_base_filter_Private->pCapMode)
{
free(omx_base_filter_Private->pCapMode);
omx_base_filter_Private->pCapMode = NULL;
}
if(omx_base_filter_Private->pBlitComp)
{
free(omx_base_filter_Private->pBlitComp);
omx_base_filter_Private->pBlitComp = NULL;
}
if(omx_base_filter_Private->pFlashType)
{
free(omx_base_filter_Private->pFlashType);
omx_base_filter_Private->pFlashType = NULL;
}
if(omx_base_filter_Private->pGamma)
{
free(omx_base_filter_Private->pGamma);
omx_base_filter_Private->pGamma = NULL;
}
if(omx_base_filter_Private->pAF_Dis)
{
free(omx_base_filter_Private->pAF_Dis);
omx_base_filter_Private->pAF_Dis = NULL;
}
if(omx_base_filter_Private->pSharp_level)
{
free(omx_base_filter_Private->pSharp_level);
omx_base_filter_Private->pSharp_level = NULL;
}
if(omx_base_filter_Private->pNs_level)
{
free(omx_base_filter_Private->pNs_level);
omx_base_filter_Private->pNs_level = NULL;
}
if(omx_base_filter_Private->pFlicktype)
{
free(omx_base_filter_Private->pFlicktype);
omx_base_filter_Private->pFlicktype = NULL;
}
if(omx_base_filter_Private->pCapExtMode)
{
free(omx_base_filter_Private->pCapExtMode);
omx_base_filter_Private->pCapExtMode = NULL;
}
if(omx_base_filter_Private->omx_camera)
{
if(omx_base_filter_Private->omx_camera->pCameraPrivate && omx_base_filter_Private->bCopy == OMX_FALSE)
{
OMXDBUG(OMXDBUG_VERB, "%s,%d\n", __FILE__, __LINE__);
omx_base_filter_Private->omx_camera->omx_camera_close(omx_base_filter_Private->omx_camera);
if(omx_base_filter_Private->nSensorType == 0)
{
if(omx_base_filter_Private->camera_isp_base_Destructor)
{ omx_base_filter_Private->camera_isp_base_Destructor(omx_base_filter_Private->omx_camera); }
}
else
{
if(omx_base_filter_Private->camera_direct_base_Destructor)
{ omx_base_filter_Private->camera_direct_base_Destructor(omx_base_filter_Private->omx_camera); }
}
}
free(omx_base_filter_Private->omx_camera);
omx_base_filter_Private->omx_camera = NULL;
}
if(omx_base_filter_Private->queue_dq)
{
queue_deinit(omx_base_filter_Private->queue_dq);
free(omx_base_filter_Private->queue_dq);
omx_base_filter_Private->queue_dq = NULL;
}
#if 0
if(omx_base_filter_Private->dMoudleIsp)
{
dlclose(omx_base_filter_Private->dMoudleIsp);
omx_base_filter_Private->dMoudleIsp = NULL;
}
if(omx_base_filter_Private->pBufferQueueInDriver)
{
queue_deinit(omx_base_filter_Private->pBufferQueueInDriver);
free(omx_base_filter_Private->pBufferQueueInDriver);
omx_base_filter_Private->pBufferQueueInDriver = NULL;
}
#endif
base_video_port_Destructor(openmaxStandPort);
return OMX_ErrorNone;
}
