static x264_frame_t *x264_frame_new( x264_t *h, int b_fdec )
{
x264_frame_t *frame;
int i_csp = x264_frame_internal_csp( h->param.i_csp );
int i_mb_count = h->mb.i_mb_count;
int i_stride, i_width, i_lines, luma_plane_count;
int i_padv = PADV << PARAM_INTERLACED;
int align = h->param.cpu&X264_CPU_CACHELINE_64 ? 64 : h->param.cpu&X264_CPU_CACHELINE_32 ? 32 : 16;
int disalign = h->param.cpu&X264_CPU_ALTIVEC ? 1<<9 : 1<<10;
CHECKED_MALLOCZERO( frame, sizeof(x264_frame_t) );
/* allocate frame data (+64 for extra data for me) */
i_width = h->mb.i_mb_width*16;
i_lines = h->mb.i_mb_height*16;
i_stride = align_stride( i_width + 2*PADH, align, disalign );
if( i_csp == X264_CSP_NV12 || i_csp == X264_CSP_NV16 )
{
luma_plane_count = 1;
frame->i_plane = 2;
for( int i = 0; i < 2; i++ )
{
frame->i_width[i] = i_width >> i;
frame->i_lines[i] = i_lines >> (i && i_csp == X264_CSP_NV12);
frame->i_stride[i] = i_stride;
}
}
int x264_threadpool_init( x264_threadpool_t **p_pool, int threads,
void (*init_func)(void *), void *init_arg )
{
if( threads <= 0 )
return -1;
x264_threadpool_t *pool;
CHECKED_MALLOCZERO( pool, sizeof(x264_threadpool_t) );
*p_pool = pool;
pool->init_func = init_func;
pool->init_arg = init_arg;
pool->threads = threads;
CHECKED_MALLOC( pool->thread_handle, pool->threads * sizeof(x264_pthread_t) );
if( x264_sync_frame_list_init( &pool->uninit, pool->threads ) ||
x264_sync_frame_list_init( &pool->run, pool->threads ) ||
x264_sync_frame_list_init( &pool->done, pool->threads ) )
goto fail;
for( int i = 0; i < pool->threads; i++ )
{
x264_threadpool_job_t *job;
CHECKED_MALLOC( job, sizeof(x264_threadpool_job_t) );
x264_sync_frame_list_push( &pool->uninit, (void*)job );
}
for( int i = 0; i < pool->threads; i++ )
if( x264_pthread_create( pool->thread_handle+i, NULL, (void*)x264_threadpool_thread, pool ) )
goto fail;
return 0;
fail:
return -1;
}
x265_weight_prediction_t *x265_weight_prediction_new ()
{
x265_weight_prediction_t *weight_prediction = NULL ;
CHECKED_MALLOCZERO( weight_prediction, sizeof(x265_weight_prediction_t) );
return weight_prediction ;
fail:
x265_weight_prediction_delete ( (void*) weight_prediction ) ;
return NULL ;
}
x265_enc_cfg_t *x265_enc_cfg_new ()
{
x265_enc_cfg_t *enc_cfg = NULL ;
CHECKED_MALLOCZERO( enc_cfg, sizeof(x265_enc_cfg_t) );
return enc_cfg ;
fail:
x265_enc_cfg_delete ( (void*) enc_cfg ) ;
return NULL ;
}
x265_enc_pic_t *x265_enc_pic_new ()
{
x265_enc_pic_t *enc_pic = NULL ;
CHECKED_MALLOCZERO( enc_pic, sizeof(x265_enc_pic_t) );
return enc_pic ;
fail:
x265_enc_pic_delete ( (void*) enc_pic ) ;
return NULL ;
}
x265_enc_pic_qp_adaptation_layer_t *x265_enc_pic_qp_adaptation_layer_new ()
{
x265_enc_pic_qp_adaptation_layer_t *enc_pic_qp_adaptation_layer = NULL ;
CHECKED_MALLOCZERO( enc_pic_qp_adaptation_layer, sizeof(x265_enc_pic_qp_adaptation_layer_t) );
return enc_pic_qp_adaptation_layer ;
fail:
x265_enc_pic_qp_adaptation_layer_delete ( (void*) enc_pic_qp_adaptation_layer ) ;
return NULL ;
}
x265_enc_qp_adaptation_unit_t *x265_enc_qp_adaptation_unit_new ()
{
x265_enc_qp_adaptation_unit_t *enc_qp_adaptation_unit = NULL ;
CHECKED_MALLOCZERO( enc_qp_adaptation_unit, sizeof(x265_enc_qp_adaptation_unit_t) );
return enc_qp_adaptation_unit ;
fail:
x265_enc_qp_adaptation_unit_delete ( (void*) enc_qp_adaptation_unit ) ;
return NULL ;
}
int x264_lookahead_init( x264_t *h )
{
x264_lookahead_t *look;
CHECKED_MALLOCZERO( look, sizeof(x264_lookahead_t) );
h->lookahead = look;
look->i_last_keyframe = - h->param.i_keyint_max;
return 0;
fail:
x264_free( look );
return -1;
}
/* load the library and functions we require from it */
x264_opencl_function_t *x264_opencl_load_library( void )
{
x264_opencl_function_t *ocl;
#undef fail
#define fail fail0
CHECKED_MALLOCZERO( ocl, sizeof(x264_opencl_function_t) );
#undef fail
#define fail fail1
ocl->library = ocl_open;
if( !ocl->library )
goto fail;
#undef fail
#define fail fail2
LOAD_OCL_FUNC( clBuildProgram, 0 );
LOAD_OCL_FUNC( clCreateBuffer, 0 );
LOAD_OCL_FUNC( clCreateCommandQueue, 0 );
LOAD_OCL_FUNC( clCreateContext, 0 );
LOAD_OCL_FUNC( clCreateImage2D, 0 );
LOAD_OCL_FUNC( clCreateKernel, 0 );
LOAD_OCL_FUNC( clCreateProgramWithBinary, 0 );
LOAD_OCL_FUNC( clCreateProgramWithSource, 0 );
LOAD_OCL_FUNC( clEnqueueCopyBuffer, 0 );
LOAD_OCL_FUNC( clEnqueueMapBuffer, 0 );
LOAD_OCL_FUNC( clEnqueueNDRangeKernel, 0 );
LOAD_OCL_FUNC( clEnqueueReadBuffer, 0 );
LOAD_OCL_FUNC( clEnqueueWriteBuffer, 0 );
LOAD_OCL_FUNC( clFinish, 0 );
LOAD_OCL_FUNC( clGetCommandQueueInfo, 0 );
LOAD_OCL_FUNC( clGetDeviceIDs, 0 );
LOAD_OCL_FUNC( clGetDeviceInfo, 0 );
LOAD_OCL_FUNC( clGetKernelWorkGroupInfo, 0 );
LOAD_OCL_FUNC( clGetPlatformIDs, 0 );
LOAD_OCL_FUNC( clGetProgramBuildInfo, 0 );
LOAD_OCL_FUNC( clGetProgramInfo, 0 );
LOAD_OCL_FUNC( clGetSupportedImageFormats, 0 );
LOAD_OCL_FUNC( clReleaseCommandQueue, 0 );
LOAD_OCL_FUNC( clReleaseContext, 0 );
LOAD_OCL_FUNC( clReleaseKernel, 0 );
LOAD_OCL_FUNC( clReleaseMemObject, 0 );
LOAD_OCL_FUNC( clReleaseProgram, 0 );
LOAD_OCL_FUNC( clSetKernelArg, 0 );
return ocl;
#undef fail
fail2:
ocl_close( ocl->library );
fail1:
x264_free( ocl );
fail0:
return NULL;
}
x265_enc_entropy_t *x265_enc_entropy_new ()
{
x265_enc_entropy_t *enc_entropy = NULL ;
CHECKED_MALLOCZERO( enc_entropy, sizeof(x265_enc_entropy_t) );
if ( x265_enc_entropy_init (enc_entropy) )
{
goto fail ;
}
return enc_entropy ;
fail:
x265_enc_entropy_delete ( (void*) enc_entropy ) ;
return NULL ;
}
static x264_frame_t *x264_frame_new( x264_t *h, int b_fdec )
{
x264_frame_t *frame;
int i_csp = x264_frame_internal_csp( h->param.i_csp );
int i_mb_count = h->mb.i_mb_count;
int i_stride, i_width, i_lines, luma_plane_count;
int i_padv = PADV << PARAM_INTERLACED;
int align = 16;
#if ARCH_X86 || ARCH_X86_64
if( h->param.cpu&X264_CPU_CACHELINE_64 )
align = 64;
else if( h->param.cpu&X264_CPU_CACHELINE_32 || h->param.cpu&X264_CPU_AVX )
align = 32;
#endif
#if ARCH_PPC
int disalign = 1<<9;
#else
int disalign = 1<<10;
#endif
CHECKED_MALLOCZERO( frame, sizeof(x264_frame_t) );
PREALLOC_INIT
/* allocate frame data (+64 for extra data for me) */
i_width = h->mb.i_mb_width*16;
i_lines = h->mb.i_mb_height*16;
i_stride = align_stride( i_width + 2*PADH, align, disalign );
if( i_csp == X264_CSP_NV12 || i_csp == X264_CSP_NV16 )
{
luma_plane_count = 1;
frame->i_plane = 2;
for( int i = 0; i < 2; i++ )
{
frame->i_width[i] = i_width >> i;
frame->i_lines[i] = i_lines >> (i && i_csp == X264_CSP_NV12);
frame->i_stride[i] = i_stride;
}
}
int x264_lookahead_init( x264_t *h, int i_slicetype_length )
{
x264_lookahead_t *look;
CHECKED_MALLOCZERO( look, sizeof(x264_lookahead_t) );
for( int i = 0; i < h->param.i_threads; i++ )
h->thread[i]->lookahead = look;
look->i_last_keyframe = - h->param.i_keyint_max;
look->b_analyse_keyframe = (h->param.rc.b_mb_tree || (h->param.rc.i_vbv_buffer_size && h->param.rc.i_lookahead))
&& !h->param.rc.b_stat_read;
look->i_slicetype_length = i_slicetype_length;
/* init frame lists */
if( x264_sync_frame_list_init( &look->ifbuf, h->param.i_sync_lookahead+3 ) ||
x264_sync_frame_list_init( &look->next, h->frames.i_delay+3 ) ||
x264_sync_frame_list_init( &look->ofbuf, h->frames.i_delay+3 ) )
goto fail;
if( !h->param.i_sync_lookahead )
return 0;
x264_t *look_h = h->thread[h->param.i_threads];
*look_h = *h;
if( x264_macroblock_cache_allocate( look_h ) )
goto fail;
if( x264_macroblock_thread_allocate( look_h, 1 ) < 0 )
goto fail;
if( x264_pthread_create( &look->thread_handle, NULL, (void*)x264_lookahead_thread, look_h ) )
goto fail;
look->b_thread_active = 1;
return 0;
fail:
x264_free( look );
return -1;
}
