/*
Multithreading support
*/
int getNumberOfProcessors() {
#if defined(_SC_NPROCESSORS_ONLN)
return sysconf(_SC_NPROCESSORS_ONLN);
#elif defined(__FreeBSD__) || defined(__APPLE__)
unsigned int len, count;
len = sizeof(count);
return sysctlbyname("hw.ncpu", &count, &len, NULL, 0);
#elif defined(_GNU_SOURCE)
return get_nprocs();
#elif defined(_WIN32)
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
return sysinfo.dwNumberOfProcessors;
#elif defined(PTW32_VERSION) || defined(__hpux)
return pthread_num_processors_np();
#else
return 1;
#endif
}
void Leafcutter::leafcut(shared_ptr<Image<Vec4f> > image, shared_ptr<LightTree > lightTree, uint32_t samples, shared_ptr<ReportHandler> report)
{
_report = report;
_image = image;
_lightTree = lightTree;
_nCore = pthread_num_processors_np();
stringstream sout;
sout << "Leafcut on " << _nCore << " threads";
if (_report) _report->beginActivity(sout.str());
uint32_t lightNum = lightTree->DirectionalLightNum() + lightTree->OrientedLightNum();
image->Alloc(lightNum, samples);
_curLine = 0;
_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_init(&_mutex, NULL);
vector<pthread_t> threads(_nCore);
_sampler->BeginPixel(samples);
for (uint64_t idx = 0; idx < threads.size(); idx++)
{
pthread_create(&threads[idx], NULL, TreeWalkThread, this);
}
for (uint64_t idx = 0; idx < threads.size(); idx++)
{
pthread_join(threads[idx], NULL);
}
_sampler->EndPixel();
pthread_mutex_destroy(&_mutex);
if (_report) _report->endActivity();
}
unsigned possibleThreadCount() {
#if defined(PTW32_VERSION) || defined(__hpux)
return pthread_num_processors_np();
#elif defined(__APPLE__) || defined(__FreeBSD__)
int count;
size_t size = sizeof(count);
return sysctlbyname("hw.ncpu", &count, &size, NULL, 0) ? 0 : count;
#elif defined(BOOST_HAS_UNISTD_H) && defined(_SC_NPROCESSORS_ONLN)
int const count = sysconf(_SC_NPROCESSORS_ONLN);
return (count > 0) ? count : 1;
#elif defined(_GNU_SOURCE)
return get_nprocs();
#else
return 1;
#endif
}
unsigned thread::hardware_concurrency()
{
#if defined(PTW32_VERSION) || defined(__hpux)
return pthread_num_processors_np();
#elif defined(__APPLE__) || defined(__FreeBSD__)
int count;
size_t size=sizeof(count);
return sysctlbyname("hw.ncpu",&count,&size,NULL,0)?0:count;
#elif defined(BOOST_HAS_UNISTD_H) && defined(_SC_NPROCESSORS_ONLN)
int const count=sysconf(_SC_NPROCESSORS_ONLN);
return (count>0)?count:0;
#elif defined(__GLIBC__)
return get_nprocs();
#else
return 0;
#endif
}
static int
xvid_gbl_info(xvid_gbl_info_t * info)
{
if (XVID_VERSION_MAJOR(info->version) != 1) /* v1.x.x */
return XVID_ERR_VERSION;
info->actual_version = XVID_VERSION;
info->build = "xvid-1.1.3";
info->cpu_flags = detect_cpu_flags();
#if defined(_SMP) && defined(WIN32)
info->num_threads = pthread_num_processors_np();;
#else
info->num_threads = 0;
#endif
return 0;
}
unsigned int Thread::getNumberOfProcessors()
{
#if __cplusplus >= 201103L
return std::thread::hardware_concurrency();
#elif defined(_SC_NPROCESSORS_ONLN)
return sysconf(_SC_NPROCESSORS_ONLN);
#elif defined(__FreeBSD__) || defined(__NetBSD__) || \
defined(__DragonFly__) || defined(__APPLE__)
unsigned int num_cpus = 1;
size_t len = sizeof(num_cpus);
int mib[2];
mib[0] = CTL_HW;
mib[1] = HW_NCPU;
sysctl(mib, 2, &num_cpus, &len, NULL, 0);
return num_cpus;
#elif defined(_GNU_SOURCE)
return get_nprocs();
#elif defined(_WIN32)
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
return sysinfo.dwNumberOfProcessors;
#elif defined(PTW32_VERSION) || defined(__hpux)
return pthread_num_processors_np();
#else
return 1;
#endif
}
unsigned EnvironmentImpl::processorCountImpl()
{
#if defined(_SC_NPROCESSORS_ONLN)
int count = sysconf(_SC_NPROCESSORS_ONLN);
if (count <= 0) count = 1;
return static_cast<int>(count);
#elif defined(POCO_OS_FAMILY_BSD)
unsigned count;
std::size_t size = sizeof(count);
if (sysctlbyname("hw.ncpu", &count, &size, 0, 0))
return 1;
else
return count;
#elif POCO_OS == POCO_OS_HPUX
return pthread_num_processors_np();
#else
return 1;
#endif
}
Par2Creator::Par2Creator(void)
: noiselevel(CommandLine::nlUnknown)
, blocksize(0)
, chunksize(0)
, inputbuffer(0)
, outputbuffer(0)
, sourcefilecount(0)
, sourceblockcount(0)
, largestfilesize(0)
, recoveryfilescheme(CommandLine::scUnknown)
, recoveryfilecount(0)
, recoveryblockcount(0)
, firstrecoveryblock(0)
, mainpacket(0)
, creatorpacket(0)
, previouslyReportedFraction (0)
, deferhashcomputation(false)
{
// Some stuff for the multi-thread optimization
pthread_mutex_init (&progressMutex, NULL);
// Go and find number of CPU's in this machine
#ifdef WIN32
numCPUs = pthread_num_processors_np();
#else // !WIN32
#ifdef CTL_HW
int lName [2] = { CTL_HW, HW_NCPU };
size_t lLen = sizeof (numCPUs);
if (sysctl(lName, 2, &numCPUs, &lLen, NULL, 0) != 0)
{
assert (false);
numCPUs = 1; // Default value if we have an error in sysctl
}
#elif defined(_SC_NPROCESSORS_ONLN)
numCPUs = sysconf( _SC_NPROCESSORS_ONLN );
#else
numCPUs = 1;
#endif // CTL_HW
#endif // !WIN32
}
int
main()
{
long result = 0;
pthread_t t;
int CPUs;
struct _timeb sysTime;
if ((CPUs = pthread_num_processors_np()) == 1)
{
printf("Test not run - it requires multiple CPUs.\n");
exit(0);
}
assert(pthread_spin_lock(&lock) == 0);
assert(pthread_create(&t, NULL, func, NULL) == 0);
while (washere == 0)
{
sched_yield();
}
do
{
sched_yield();
_ftime(&sysTime);
}
while (GetDurationMilliSecs(currSysTimeStart, sysTime) <= 1000);
assert(pthread_spin_unlock(&lock) == 0);
assert(pthread_join(t, (void **) &result) == 0);
assert(result > 1000);
assert(pthread_spin_destroy(&lock) == 0);
assert(washere == 1);
return 0;
}
void time_step( )
{
#ifdef __GLIBC__
int processor_count = get_nprocs( );
#else
int processor_count = pthread_num_processors_np( );
#endif
int objects_per_processor = OBJECT_COUNT / processor_count;
struct Work_Unit *chunks =
(struct Work_Unit *)malloc( processor_count * sizeof(struct Work_Unit) );
pthread_t *thread_IDs =
(pthread_t *)malloc( processor_count * sizeof(pthread_t) );
// Create a thread for each CPU and set it working on its work unit.
for( int i = 0; i < processor_count; ++i ) {
struct Work_Unit *chunk =
(struct Work_Unit *)malloc( sizeof( struct Work_Unit ) );
chunk->start_index = i * objects_per_processor;
if( i == processor_count - 1 )
chunk->stop_index = OBJECT_COUNT;
else
chunk->stop_index = ( i + 1 ) * objects_per_processor;
pthread_create( &thread_IDs[i], NULL, compute_next_dynamics, chunk);
}
// Wait for all thread to end.
for( int i = 0; i < processor_count; ++i ) {
pthread_join( thread_IDs[i], NULL );
}
// Swap the dynamics arrays.
ObjectDynamics *temp = current_dynamics;
current_dynamics = next_dynamics;
next_dynamics = temp;
free(chunks);
free(thread_IDs);
}
unsigned gmlCPUCount() {
#ifdef _WIN32
SYSTEM_INFO info={0};
GetSystemInfo(&info);
return info.dwNumberOfProcessors;
#else
# if defined(PTW32_VERSION) || defined(__hpux)
return pthread_num_processors_np();
# elif defined(__linux__)
return get_nprocs();
# elif defined(__APPLE__) || defined(__FreeBSD__)
int count;
size_t size=sizeof(count);
return sysctlbyname("hw.ncpu",&count,&size,NULL,0)?0:count;
# elif defined(__sun)
int const count=sysconf(_SC_NPROCESSORS_ONLN);
return (count>0)?count:0;
# else
return 0;
# endif
#endif
}
/* We hold the allocation lock. */
void GC_thr_init(void)
{
# ifndef GC_DARWIN_THREADS
int dummy;
# endif
GC_thread t;
if (GC_thr_initialized) return;
GC_thr_initialized = TRUE;
# ifdef HANDLE_FORK
/* Prepare for a possible fork. */
pthread_atfork(GC_fork_prepare_proc, GC_fork_parent_proc,
GC_fork_child_proc);
# endif /* HANDLE_FORK */
# if defined(INCLUDE_LINUX_THREAD_DESCR)
/* Explicitly register the region including the address */
/* of a thread local variable. This should include thread */
/* locals for the main thread, except for those allocated */
/* in response to dlopen calls. */
{
ptr_t thread_local_addr = (ptr_t)(&dummy_thread_local);
ptr_t main_thread_start, main_thread_end;
if (!GC_enclosing_mapping(thread_local_addr, &main_thread_start,
&main_thread_end)) {
ABORT("Failed to find mapping for main thread thread locals");
}
GC_add_roots_inner(main_thread_start, main_thread_end, FALSE);
}
# endif
/* Add the initial thread, so we can stop it. */
t = GC_new_thread(pthread_self());
# ifdef GC_DARWIN_THREADS
t -> stop_info.mach_thread = mach_thread_self();
# else
t -> stop_info.stack_ptr = (ptr_t)(&dummy);
# endif
t -> flags = DETACHED | MAIN_THREAD;
GC_stop_init();
/* Set GC_nprocs. */
{
char * nprocs_string = GETENV("GC_NPROCS");
GC_nprocs = -1;
if (nprocs_string != NULL) GC_nprocs = atoi(nprocs_string);
}
if (GC_nprocs <= 0) {
# if defined(GC_HPUX_THREADS)
GC_nprocs = pthread_num_processors_np();
# endif
# if defined(GC_OSF1_THREADS) || defined(GC_AIX_THREADS) \
|| defined(GC_SOLARIS_THREADS) || defined(GC_GNU_THREADS)
GC_nprocs = sysconf(_SC_NPROCESSORS_ONLN);
if (GC_nprocs <= 0) GC_nprocs = 1;
# endif
# if defined(GC_IRIX_THREADS)
GC_nprocs = sysconf(_SC_NPROC_ONLN);
if (GC_nprocs <= 0) GC_nprocs = 1;
# endif
# if defined(GC_NETBSD_THREADS)
GC_nprocs = get_ncpu();
# endif
# if defined(GC_OPENBSD_THREADS)
GC_nprocs = 1;
# endif
# if defined(GC_DARWIN_THREADS) || defined(GC_FREEBSD_THREADS)
int ncpus = 1;
size_t len = sizeof(ncpus);
sysctl((int[2]) {CTL_HW, HW_NCPU}, 2, &ncpus, &len, NULL, 0);
// init driver
static int init(sh_video_t *sh){
struct lavc_param *lavc_param = &sh->opts->lavc_param;
AVCodecContext *avctx;
vd_ffmpeg_ctx *ctx;
AVCodec *lavc_codec;
int lowres_w=0;
int do_vis_debug= lavc_param->vismv || (lavc_param->debug&(FF_DEBUG_VIS_MB_TYPE|FF_DEBUG_VIS_QP));
if(!avcodec_initialized){
avcodec_init();
avcodec_register_all();
avcodec_initialized=1;
}
ctx = sh->context = malloc(sizeof(vd_ffmpeg_ctx));
if (!ctx)
return 0;
memset(ctx, 0, sizeof(vd_ffmpeg_ctx));
lavc_codec = (AVCodec *)avcodec_find_decoder_by_name(sh->codec->dll);
if(!lavc_codec){
mp_tmsg(MSGT_DECVIDEO, MSGL_ERR, "Cannot find codec '%s' in libavcodec...\n", sh->codec->dll);
uninit(sh);
return 0;
}
if(sh->opts->vd_use_slices && (lavc_codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND) && !do_vis_debug)
ctx->do_slices=1;
if(lavc_codec->capabilities&CODEC_CAP_DR1 && !do_vis_debug && lavc_codec->id != CODEC_ID_H264 && lavc_codec->id != CODEC_ID_INTERPLAY_VIDEO && lavc_codec->id != CODEC_ID_ROQ)
ctx->do_dr1=1;
ctx->b_age= ctx->ip_age[0]= ctx->ip_age[1]= 256*256*256*64;
ctx->ip_count= ctx->b_count= 0;
ctx->pic = avcodec_alloc_frame();
ctx->avctx = avcodec_alloc_context();
avctx = ctx->avctx;
avctx->opaque = sh;
avctx->codec_type = CODEC_TYPE_VIDEO;
avctx->codec_id = lavc_codec->id;
if (lavc_codec->capabilities & CODEC_CAP_HWACCEL // XvMC
|| lavc_codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) {
ctx->do_dr1 = true;
ctx->do_slices = true;
lavc_param->threads = 1;
avctx->get_format = get_format;
avctx->get_buffer = get_buffer;
avctx->release_buffer = release_buffer;
avctx->reget_buffer = get_buffer;
avctx->draw_horiz_band = draw_slice;
if (lavc_codec->capabilities & CODEC_CAP_HWACCEL)
mp_msg(MSGT_DECVIDEO, MSGL_V, "[VD_FFMPEG] XVMC-accelerated "
"MPEG-2.\n");
if (lavc_codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
mp_msg(MSGT_DECVIDEO, MSGL_V, "[VD_FFMPEG] VDPAU hardware "
"decoding.\n");
avctx->slice_flags = SLICE_FLAG_CODED_ORDER|SLICE_FLAG_ALLOW_FIELD;
}
if ( lavc_param->threads == 0 ) {
#if defined(_WIN32)
lavc_param->threads = pthread_num_processors_np();
#elif defined(__linux__)
unsigned int bit;
int np;
cpu_set_t p_aff;
memset( &p_aff, 0, sizeof(p_aff) );
sched_getaffinity( 0, sizeof(p_aff), &p_aff );
for( np = 0, bit = 0; bit < sizeof(p_aff); bit++ )
np += (((uint8_t *)&p_aff)[bit / 8] >> (bit % 8)) & 1;
lavc_param->threads = np;
#elif defined(__BEOS__)
system_info info;
get_system_info( &info );
lavc_param->threads = info.cpu_count;
#elif defined(__MACH__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__OpenBSD__)
int numberOfCPUs;
size_t length = sizeof( numberOfCPUs );
#ifdef __OpenBSD__
int mib[2] = { CTL_HW, HW_NCPU };
if( sysctl(mib, 2, &numberOfCPUs, &length, NULL, 0) )
#else
if( sysctlbyname("hw.ncpu", &numberOfCPUs, &length, NULL, 0) )
#endif
{
numberOfCPUs = 1;
}
lavc_param->threads = numberOfCPUs;
#else /* No CPU detection routine available */
lavc_param->threads = 1;
#endif
}
// init driver
static int init(sh_video_t *sh){
AVCodecContext *avctx;
vd_ffmpeg_ctx *ctx;
AVCodec *lavc_codec;
int lowres_w=0;
int do_vis_debug= lavc_param_vismv || (lavc_param_debug&(FF_DEBUG_VIS_MB_TYPE|FF_DEBUG_VIS_QP));
// slice is rather broken with threads, so disable that combination unless
// explicitly requested
int use_slices = vd_use_slices > 0 || (vd_use_slices < 0 && lavc_param_threads <= 1);
AVDictionary *opts = NULL;
init_avcodec();
ctx = sh->context = malloc(sizeof(vd_ffmpeg_ctx));
if (!ctx)
return 0;
memset(ctx, 0, sizeof(vd_ffmpeg_ctx));
lavc_codec = avcodec_find_decoder_by_name(sh->codec->dll);
if(!lavc_codec){
mp_msg(MSGT_DECVIDEO, MSGL_ERR, MSGTR_MissingLAVCcodec, sh->codec->dll);
uninit(sh);
return 0;
}
if (auto_threads) {
#if (defined(__MINGW32__) && HAVE_PTHREADS)
lavc_param_threads = pthread_num_processors_np();
#elif defined(__linux__)
/* Code stolen from x264 :) */
unsigned int bit;
int np;
cpu_set_t p_aff;
memset( &p_aff, 0, sizeof(p_aff) );
sched_getaffinity( 0, sizeof(p_aff), &p_aff );
for( np = 0, bit = 0; bit < sizeof(p_aff); bit++ )
np += (((uint8_t *)&p_aff)[bit / 8] >> (bit % 8)) & 1;
lavc_param_threads = np;
#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) || defined(__APPLE__) || defined (__NetBSD__) || defined(__OpenBSD__)
/* Code stolen from x264 :) */
int numberOfCPUs;
size_t length = sizeof( numberOfCPUs );
#if defined (__NetBSD__) || defined(__OpenBSD__)
int mib[2] = { CTL_HW, HW_NCPU };
if( sysctl(mib, 2, &numberOfCPUs, &length, NULL, 0) )
#else
if( sysctlbyname("hw.ncpu", &numberOfCPUs, &length, NULL, 0) )
#endif
{
numberOfCPUs = 1;
}
lavc_param_threads = numberOfCPUs;
#endif
if(lavc_codec->id == CODEC_ID_H264 || lavc_codec->id == CODEC_ID_FFH264
|| lavc_codec->id == CODEC_ID_MPEG2TS || lavc_codec->id == CODEC_ID_MPEG2VIDEO_XVMC) {
if (lavc_param_threads > 16) lavc_param_threads = 16;
if (lavc_param_threads > 1 && (lavc_codec->id == CODEC_ID_MPEG2VIDEO ||
lavc_codec->id == CODEC_ID_MPEG2TS || lavc_codec->id == CODEC_ID_MPEG2VIDEO_XVMC))
vd_use_slices = 0;
mp_msg(MSGT_DECVIDEO, MSGL_INFO, "Spawning %d decoding thread%s...\n", lavc_param_threads, lavc_param_threads == 1 ? "" : "s");
} else {
lavc_param_threads = 1;
}
}
if(use_slices && (lavc_codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND) && !do_vis_debug)
ctx->do_slices=1;
if(lavc_codec->capabilities&CODEC_CAP_DR1 && !do_vis_debug && lavc_codec->id != CODEC_ID_INTERPLAY_VIDEO && lavc_codec->id != CODEC_ID_VP8)
ctx->do_dr1=1;
ctx->nonref_dr = lavc_codec->id == CODEC_ID_H264;
ctx->ip_count= ctx->b_count= 0;
ctx->pic = avcodec_alloc_frame();
ctx->avctx = avcodec_alloc_context3(lavc_codec);
avctx = ctx->avctx;
avctx->opaque = sh;
avctx->codec_id = lavc_codec->id;
avctx->get_format = get_format;
if(ctx->do_dr1){
avctx->flags|= CODEC_FLAG_EMU_EDGE;
avctx-> get_buffer= get_buffer;
avctx->release_buffer= release_buffer;
avctx-> reget_buffer= get_buffer;
}
avctx->flags|= lavc_param_bitexact;
avctx->coded_width = sh->disp_w;
avctx->coded_height= sh->disp_h;
avctx->workaround_bugs= lavc_param_workaround_bugs;
switch (lavc_param_error_resilience) {
case 5:
avctx->err_recognition |= AV_EF_EXPLODE | AV_EF_COMPLIANT | AV_EF_CAREFUL;
break;
case 4:
case 3:
avctx->err_recognition |= AV_EF_AGGRESSIVE;
// Fallthrough
case 2:
avctx->err_recognition |= AV_EF_COMPLIANT;
// Fallthrough
case 1:
avctx->err_recognition |= AV_EF_CAREFUL;
}
lavc_param_gray|= CODEC_FLAG_GRAY;
#ifdef CODEC_FLAG2_SHOW_ALL
if(!lavc_param_wait_keyframe) avctx->flags2 |= CODEC_FLAG2_SHOW_ALL;
#endif
avctx->flags2|= lavc_param_fast;
avctx->codec_tag= sh->format;
avctx->stream_codec_tag= sh->video.fccHandler;
avctx->idct_algo= lavc_param_idct_algo;
avctx->error_concealment= lavc_param_error_concealment;
avctx->debug= lavc_param_debug;
if (lavc_param_debug)
av_log_set_level(AV_LOG_DEBUG);
avctx->debug_mv= lavc_param_vismv;
avctx->skip_top = lavc_param_skip_top;
avctx->skip_bottom= lavc_param_skip_bottom;
if(lavc_param_lowres_str != NULL)
{
sscanf(lavc_param_lowres_str, "%d,%d", &lavc_param_lowres, &lowres_w);
if(lavc_param_lowres < 1 || lavc_param_lowres > 16 || (lowres_w > 0 && avctx->width < lowres_w))
lavc_param_lowres = 0;
avctx->lowres = lavc_param_lowres;
}
avctx->skip_loop_filter = str2AVDiscard(lavc_param_skip_loop_filter_str);
avctx->skip_idct = str2AVDiscard(lavc_param_skip_idct_str);
avctx->skip_frame = str2AVDiscard(lavc_param_skip_frame_str);
if(lavc_avopt){
if (parse_avopts(avctx, lavc_avopt) < 0 &&
(!lavc_codec->priv_class ||
parse_avopts(avctx->priv_data, lavc_avopt) < 0)) {
mp_msg(MSGT_DECVIDEO, MSGL_ERR, "Your options /%s/ look like gibberish to me pal\n", lavc_avopt);
uninit(sh);
return 0;
}
}
skip_idct = avctx->skip_idct;
skip_frame = avctx->skip_frame;
mp_dbg(MSGT_DECVIDEO, MSGL_DBG2, "libavcodec.size: %d x %d\n", avctx->width, avctx->height);
switch (sh->format) {
case mmioFOURCC('S','V','Q','3'):
/* SVQ3 extradata can show up as sh->ImageDesc if demux_mov is used, or
in the phony AVI header if demux_lavf is used. The first case is
handled here; the second case falls through to the next section. */
if (sh->ImageDesc) {
avctx->extradata_size = (*(int *)sh->ImageDesc) - sizeof(int);
avctx->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
memcpy(avctx->extradata, ((int *)sh->ImageDesc)+1, avctx->extradata_size);
break;
}
/* fallthrough */
case mmioFOURCC('A','V','R','n'):
case mmioFOURCC('M','J','P','G'):
/* AVRn stores huffman table in AVI header */
/* Pegasus MJPEG stores it also in AVI header, but it uses the common
MJPG fourcc :( */
if (!sh->bih || sh->bih->biSize <= sizeof(*sh->bih))
break;
av_dict_set(&opts, "extern_huff", "1", 0);
avctx->extradata_size = sh->bih->biSize-sizeof(*sh->bih);
avctx->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
memcpy(avctx->extradata, sh->bih+1, avctx->extradata_size);
#if 0
{
int x;
uint8_t *p = avctx->extradata;
for (x=0; x<avctx->extradata_size; x++)
mp_msg(MSGT_DECVIDEO, MSGL_INFO, "[%x] ", p[x]);
mp_msg(MSGT_DECVIDEO, MSGL_INFO, "\n");
}
#endif
break;
case mmioFOURCC('R', 'V', '1', '0'):
case mmioFOURCC('R', 'V', '1', '3'):
case mmioFOURCC('R', 'V', '2', '0'):
case mmioFOURCC('R', 'V', '3', '0'):
case mmioFOURCC('R', 'V', '4', '0'):
if(sh->bih->biSize<sizeof(*sh->bih)+8){
/* only 1 packet per frame & sub_id from fourcc */
avctx->extradata_size= 8;
avctx->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
((uint32_t *)avctx->extradata)[0] = 0;
((uint32_t *)avctx->extradata)[1] =
(sh->format == mmioFOURCC('R', 'V', '1', '3')) ? 0x10003001 : 0x10000000;
} else {
/* has extra slice header (demux_rm or rm->avi streamcopy) */
avctx->extradata_size = sh->bih->biSize-sizeof(*sh->bih);
avctx->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
memcpy(avctx->extradata, sh->bih+1, avctx->extradata_size);
}
avctx->sub_id= AV_RB32(avctx->extradata+4);
// printf("%X %X %d %d\n", extrahdr[0], extrahdr[1]);
break;
default:
if (!sh->bih || sh->bih->biSize <= sizeof(*sh->bih))
break;
avctx->extradata_size = sh->bih->biSize-sizeof(*sh->bih);
avctx->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
memcpy(avctx->extradata, sh->bih+1, avctx->extradata_size);
break;
}
if(sh->bih)
avctx->bits_per_coded_sample= sh->bih->biBitCount;
avctx->thread_count = lavc_param_threads;
avctx->thread_type = FF_THREAD_FRAME | FF_THREAD_SLICE;
if(lavc_codec->capabilities & CODEC_CAP_HWACCEL)
// HACK around badly placed checks in mpeg_mc_decode_init
set_format_params(avctx, PIX_FMT_XVMC_MPEG2_IDCT);
/* open it */
if (avcodec_open2(avctx, lavc_codec, &opts) < 0) {
mp_msg(MSGT_DECVIDEO, MSGL_ERR, MSGTR_CantOpenCodec);
uninit(sh);
return 0;
}
av_dict_free(&opts);
// this is necessary in case get_format was never called and init_vo is
// too late e.g. for H.264 VDPAU
set_format_params(avctx, avctx->pix_fmt);
mp_msg(MSGT_DECVIDEO, MSGL_V, "INFO: libavcodec init OK!\n");
return 1; //mpcodecs_config_vo(sh, sh->disp_w, sh->disp_h, IMGFMT_YV12);
}
