/* * Copyright (C) 2001-2002 the xine project * * This file is part of xine, a free video player. * * xine is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * xine is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA * * $Id: xine_decoder.c,v 1.44 2002/12/06 01:44:06 miguelfreitas Exp $ * * xine decoder plugin using divx4 * * by Harm van der Heijden * Based on the ffmpeg xine plugin, with ideas from avifile's * (http://avifile.sourceforge.net) divx4 plugin. * * Requires the divxdecore library. Find it at http://www.divx.com or * http://avifile.sourceforge.net * This plugin may or may not work with the open source codec OpenDivx. * * This is My First Plugin (tm). Read the source comments for hairy details. * */ /* 1: catch segmentation fault signal when checking version of libdivxdecore * 0: don't try to catch * set to 0 if the signal stuff gives problems. tested in x86 linux w/ glibc2. */ #define CATCH_SIGSEGV 1 #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #include #include #include "xine_internal.h" #include "video_out.h" #include "buffer.h" #include "metronom.h" #include "xineutils.h" #include "decore-if.h" #if CATCH_SIGSEGV #include /* #define LOG */ /* to be able to restore the old handler */ void (*old_handler)(int); void catch_sigsegv(int sig) { printf("divx4: caught SIGSEGV, caused by libdivxdecore.\n" "divx4: please uninstall this library or disable the libdivxdecore\n" "divx4: version check by setting the following line in HOME/.xinerc:\n" "divx4: divx4_forceversion:1\n" "divx4: see xine-ui/doc/README.divx4 for details.\n" "divx4: fatal error; exiting.\n"); abort(); } #endif typedef struct divx4_decoder_s { video_decoder_t video_decoder; vo_instance_t *video_out; int video_step; int decoder_ok; xine_bmiheader bih; unsigned char *buf; int size; int bufsize; decoreFunc decore; /* ptr to decore function in libdivxdecore */ /* version as reported by decore with GET_OPT_VERSION command */ int version; /* whether to decode MSMPEG4_V3 format (aka divx ;-) and divx 3.11-- thank god they dropped the smileys with divx4) */ int use_311_compat; /* postprocessing level; currently valid values 0-6 (internally 0-100) set by divx4_postproc in .xinerc */ int postproc; /* can we handle 311 format? No easy way to find out (divx4linux can, OpenDivx cannot, so the user can set it in .xinerc. If 0, can_handle only returns MPEG4, yielding 311 to ffmpeg */ int can_handle_311; int skipframes; } divx4_decoder_t; #define VIDEOBUFSIZE 128*1024 static char* decore_retval(int ret) { static char buf[128]; switch (ret) { case DEC_OK: return "DEC_OK"; case DEC_MEMORY: return "DEC_MEMORY"; case DEC_BAD_FORMAT: return "DEC_BAD_FORMAT"; case DEC_EXIT: return "DEC_EXIT"; } sprintf(buf, "[Unknown code %d]", ret); return buf; } /* try to get the version libdivxdecore */ static void divx4_get_version(divx4_decoder_t *this) { /* if version set in xine config file, do not attempt further checking * (but do print a warning about this!) */ if (this->version) { /* this dangerous stuff warrants an extra warning */ printf("divx4: assuming libdivxdecore version is %d\n", this->version); return; } #if CATCH_SIGSEGV /* try to catch possible segmentation fault triggered by version check. * old versions of OpenDivx are known to do this. * we have to exit(1) in case it happens, but at least the user'll know * what happened */ old_handler = signal(SIGSEGV, catch_sigsegv); if (old_handler == SIG_ERR) printf("divx4: failed to set SIGSEGV handler for libdivxdecore version check. Danger!\n"); /* ask decore for version, using arbitrary handle 123 */ this->version = this->decore(123, DEC_OPT_VERSION, 0, 0); /* restore old signal handler */ if (old_handler != SIG_ERR) signal(SIGSEGV, old_handler); #else /* no SIGSEGV catching, let's hope survive this... */ this->version = this->decore(123, DEC_OPT_VERSION, 0, 0); #endif if (this->version < 100) { /* must be an error code */ printf("divx4: libdivxdecore failed to return version number (returns %s)\n", decore_retval(this->version)); this->version = 0; } printf("divx4: found divx4 or OpenDivx decore library, version %d\n", this->version); } /* check to see if the libdivxdecore version is recent enough. * returns 1 if ok, 0 if not. */ static int divx4_check_version(divx4_decoder_t *this) { /* now check the version * oktober '01 and later are ok. (early august releases had a (possible) * problem with DEC_OPT_RELEASE, which is very important currently) */ if (this->version < 20011000) { printf("divx4: libdivxdecore version \"%d\" too old. Need 20011000 or later\n" "divx4: see README.divx4 for details on where to find libdivxdecore.\n", this->version); return 0; } return 1; } static void divx4_set_pp(divx4_decoder_t *this) { DEC_SET setpp; /* for setting postproc level */ int ret; #ifdef LOG printf ("divx4: this->decoder_ok=%d\n", this->decoder_ok); #endif if (!this->decoder_ok) return; /* multiply postproc level by 10 for internal consumption */ printf("divx4: Setting post processing level to %d (see ~/.xine/options)\n" "divx4: Valid range 0-6, reduce if you get frame drop\n", this->postproc); setpp.postproc_level = this->postproc*10; setpp.deblock_hor_luma = 0; setpp.deblock_ver_luma = 0; setpp.deblock_hor_chr = 0; setpp.deblock_ver_chr = 0; setpp.dering_luma = 0; setpp.dering_chr = 0; setpp.pp_semaphore = 0; ret = this->decore((unsigned long)this, DEC_OPT_SETPP, &setpp, 0); if (ret != DEC_OK) { printf("divx4: decore DEC_OPT_SETPP command returned %s.\n", decore_retval(ret)); /* perhaps not fatal, so we'll continue */ } } /* helper function to initialize decore */ static int divx4_init_decoder(divx4_decoder_t *this, buf_element_t *buf) { DEC_PARAM param; /* for init */ int ret, codec_type; #ifdef LOG printf ("divx4: init_decoder\n"); #endif memcpy ( &this->bih, buf->content, sizeof (xine_bmiheader)); this->video_step = buf->decoder_info[1]; codec_type = buf->type & 0xFFFF0000; /* do we need divx 3.11 compatibility mode? */ switch (buf->type & 0xFFFF0000) { case BUF_VIDEO_MSMPEG4_V1: case BUF_VIDEO_MSMPEG4_V2: case BUF_VIDEO_MSMPEG4_V3: if (this->version >= 20020303) { param.codec_version=311; this->use_311_compat = 0; } else { this->use_311_compat = 1; } break; case BUF_VIDEO_MPEG4: case BUF_VIDEO_DIVX5: if (this->version >= 20020303) param.codec_version=500; this->use_311_compat = 0; if (this->version >= 20020303) param.codec_version=500; break; default: printf ("divx4: unknown video format (buftype: 0x%08X)\n", buf->type & 0xFFFF0000); } /* setup decoder; inspired by avifile's plugin */ param.x_dim=this->bih.biWidth; param.y_dim=this->bih.biHeight; param.time_incr = 15; /* no idea what this does */ param.build_number=0; param.output_format=DEC_USER; param.build_number=0; memset(¶m.buffers, 0, sizeof(param.buffers)); ret = this->decore((unsigned long)this, DEC_OPT_INIT, ¶m, &this->bih); if (ret != DEC_OK) { printf("divx4: decore DEC_OPT_INIT command returned %s.\n", decore_retval(ret)); return 0; } this->decoder_ok = 1; divx4_set_pp( this ); return 1; } /* helper function to copy data from decore's internal buffer to a vo frame */ static inline void divx4_copy_frame(divx4_decoder_t *this, vo_frame_t *img, DEC_PICTURE pict) { /* We need to copy the yuv data from the decoder's internal buffers. Y size is width*height, U and V width*height/4 */ int i; int src_offset,dst_offset; /* copy y data; use shortcut if stride_y equals width */ src_offset = 0; dst_offset = 0; if (pict.stride_y == img->pitches[0]) { xine_fast_memcpy(img->base[0]+dst_offset, pict.y, img->pitches[0]*this->bih.biHeight); dst_offset += img->pitches[0] * this->bih.biHeight; } else { /* copy line by line */ for (i=0; ibih.biHeight; i++) { xine_fast_memcpy(img->base[0]+dst_offset, pict.y+src_offset, this->bih.biWidth); src_offset += pict.stride_y; dst_offset += img->pitches[0]; } } /* same for u,v data, but at 1/4 resolution. FIXME: Weird... I thought YV12 means order y-v-u, yet base[1] seems to be u and base[2] is v. */ /* copy u and v data */ src_offset = 0; dst_offset = 0; if (pict.stride_uv == img->pitches[1] && pict.stride_uv == img->pitches[2]) { xine_fast_memcpy(img->base[1]+dst_offset, pict.u, (img->pitches[1]*this->bih.biHeight)/4); xine_fast_memcpy(img->base[2]+dst_offset, pict.v, (img->pitches[2]*this->bih.biHeight)/4); dst_offset += (this->bih.biWidth*this->bih.biHeight)/4; } else { int dst_offset_v = 0; for (i=0; ibih.biHeight>>1; i++) { xine_fast_memcpy(img->base[1]+dst_offset, pict.u+src_offset, this->bih.biWidth/2); xine_fast_memcpy(img->base[2]+dst_offset_v, pict.v+src_offset, this->bih.biWidth/2); src_offset += pict.stride_uv; dst_offset += img->pitches[1]; dst_offset_v += img->pitches[2]; } } } static int divx4_can_handle (video_decoder_t *this_gen, int buf_type) { divx4_decoder_t *this = (divx4_decoder_t *) this_gen; buf_type &= 0xFFFF0000; #ifdef LOG printf ("divx4: can_handle\n"); #endif /* divx4 currently does not support MSMPEG4 v1/v2 */ return ( (buf_type == BUF_VIDEO_MSMPEG4_V3 && this->can_handle_311) || /* buf_type == BUF_VIDEO_MSMPEG4_V2 || */ (buf_type == BUF_VIDEO_MPEG4) || (buf_type == BUF_VIDEO_DIVX5)); } /* copied verbatim from ffmpeg plugin */ static void divx4_init (video_decoder_t *this_gen, vo_instance_t *video_out) { divx4_decoder_t *this = (divx4_decoder_t *) this_gen; #ifdef LOG printf ("divx4: divx4_init\n"); #endif this->video_out = video_out; this->decoder_ok = 0; this->buf = NULL; } static void divx4_decode_data (video_decoder_t *this_gen, buf_element_t *buf) { DEC_FRAME frame; /* for getting a frame */ DEC_PICTURE pict;/* contains ptrs to the decoders internal yuv buffers */ vo_frame_t *img; /* video out frame */ int ret; divx4_decoder_t *this = (divx4_decoder_t *) this_gen; #ifdef LOG printf ("divx4: decoding buffer %08x, flags = %08x\n", buf, buf->decoder_flags); #endif if (buf->decoder_flags & BUF_FLAG_PREVIEW) return; if (buf->decoder_flags & BUF_FLAG_HEADER) { /* need to initialize */ /* only proceed if version is good and initialization succeeded */ #ifdef LOG printf ("divx4: get_version...\n"); #endif divx4_get_version(this); this->decoder_ok = ( divx4_check_version(this) && divx4_init_decoder (this, buf) ); if (this->decoder_ok) { this->video_out->open (this->video_out); if( this->buf ) free( this->buf ); this->buf = malloc( VIDEOBUFSIZE ); this->bufsize = VIDEOBUFSIZE; this->skipframes = 0; } return; } if (! this->decoder_ok) { /* don't try to do anything */ /* if it is because of the version, print the warning again. * otherwise it's an unknown internal error. */ if (divx4_check_version(this) != 0) /* version is good */ printf("divx4: internal error; decoder not initialized.\n"); return; } if( this->size + buf->size > this->bufsize ) { this->bufsize = this->size + 2 * buf->size; printf("divx4: increasing source buffer to %d to avoid overflow.\n", this->bufsize); this->buf = realloc( this->buf, this->bufsize ); } xine_fast_memcpy (&this->buf[this->size], buf->content, buf->size); this->size += buf->size; if (buf->decoder_flags & BUF_FLAG_FRAMERATE) this->video_step = buf->decoder_info[0]; if (buf->decoder_flags & BUF_FLAG_FRAME_END) { /* need to decode a frame */ /* allocate image (taken from ffmpeg plugin) */ img = this->video_out->get_frame (this->video_out, this->bih.biWidth, this->bih.biHeight, XINE_VO_ASPECT_DONT_TOUCH, XINE_IMGFMT_YV12, VO_BOTH_FIELDS); img->pts = buf->pts; img->duration = this->video_step; /* setup the decode frame parameters, as demonstrated by avifile. Old versions used DEC_YV12, but that was basically wrong and just happened to work with the Xv driver. Now DEC_USER is the only option. */ frame.bitstream=this->buf; frame.bmp=&pict; /* decore will set ptrs to internal y,u&v buffers */ frame.length=this->size; frame.render_flag=1; frame.stride=this->bih.biWidth; if(this->use_311_compat) ret = this->decore((unsigned long)this, DEC_OPT_FRAME_311, &frame, 0); else ret = this->decore((unsigned long)this, DEC_OPT_FRAME, &frame, 0); if (ret != DEC_OK || this->skipframes) { if( !this->skipframes ) printf("divx4: decore DEC_OPT_FRAME command returned %s.\n", decore_retval(ret)); img->bad_frame = 1; /* better skip this one */ } else { divx4_copy_frame(this, img, pict); img->bad_frame = 0; } this->skipframes = img->draw(img); if( this->skipframes < 0 ) this->skipframes = 0; img->free(img); this->size = 0; } } static void divx4_close (video_decoder_t *this_gen) { divx4_decoder_t *this = (divx4_decoder_t *) this_gen; printf ("divx4: close\n"); if (this->decoder_ok) { /* FIXME: this segfaults here */ /* Note: we NEED this; after 0.9.4, xine closes and reopens * decoders when seeking. If DEC_OPT_RELEASE is disabled, it will * cause a memory leak of plusminus 5M per shot */ this->decore((unsigned long)this, DEC_OPT_RELEASE, 0, 0); this->decoder_ok = 0; this->video_out->close(this->video_out); } if (this->buf) free(this->buf); this->buf = NULL; } static void divx4_update_postproc(void *this_gen, xine_cfg_entry_t *entry) { divx4_decoder_t *this = (divx4_decoder_t *) this_gen; #ifdef LOG printf ("divx4: update_postproc this=0x%08x, decoder_ok = %d\n", this, this->decoder_ok); #endif if( this->postproc != entry->num_value) { this->postproc = entry->num_value; divx4_set_pp( this ); } } static char *divx4_get_id(void) { #ifdef LOG printf ("divx4: get_id\n"); #endif return "divx4 video decoder"; } static void divx4_flush(video_decoder_t *this_gen) { #ifdef LOG printf ("divx4: flush\n"); #endif } static void divx4_reset(video_decoder_t *this_gen) { /* seems to handle seeking quite nicelly without any code here */ #ifdef LOG printf ("divx4: reset\n"); #endif } static void divx4_dispose(video_decoder_t *this_gen) { #ifdef LOG printf ("divx4: dispose\n"); #endif free (this_gen); } /* This is pretty generic. I took the liberty to increase the priority over that of libffmpeg :-) */ static void *init_video_decoder_plugin (xine_t *xine, void *data) { divx4_decoder_t *this ; char *libdecore_name; void *libdecore_handle; decoreFunc libdecore_func = 0; config_values_t *cfg; cfg = xine->config; /* Try to dlopen libdivxdecore, then look for decore function if it fails, print a message and return 0 so that xine ignores us from then on. */ libdecore_name = cfg->register_string (cfg, "codec.divx4_libdivxdecore", "libdivxdecore.so", _("Relative path to libdivxdecore.so to open"), NULL, 0, NULL, NULL); libdecore_handle = dlopen(libdecore_name, RTLD_LAZY); if (libdecore_handle) libdecore_func = dlsym(libdecore_handle, "decore"); if (! libdecore_func) { /* no library or no decore function. this plugin can do nothing */ return NULL; } this = (divx4_decoder_t *) malloc (sizeof (divx4_decoder_t)); this->decoder_ok = 0; this->video_decoder.init = divx4_init; this->video_decoder.decode_data = divx4_decode_data; this->video_decoder.close = divx4_close; this->video_decoder.get_identifier = divx4_get_id; this->video_decoder.flush = divx4_flush; this->video_decoder.reset = divx4_reset; this->video_decoder.dispose = divx4_dispose; this->decore = libdecore_func; this->postproc = cfg->register_range (cfg, "codec.divx4_postproc", 3, 0, 6, _("the postprocessing level, 0 = none and fast, 6 = all and slow"), NULL, 10, divx4_update_postproc, this); this->can_handle_311 = cfg->register_bool (cfg, "codec.divx4_msmpeg4v3", 1, _("use divx4 plugin for msmpeg4v3 streams"), NULL, 10, NULL, NULL); this->size = 0; /* allow override of version checking by user */ this->version = cfg->register_num(cfg, "codec.divx4_forceversion", 0, _("Divx version to check for (set to 0 (default) if unsure)"), NULL, 20, NULL, NULL); /* if the version set in the config file, we can check right now. * otherwise postpone until we retrieve the version from the library * in the first decoding call (we'll only ever get there if this * plugin has the highest priority, which by default it has not). */ if ( this->version != 0 && divx4_check_version(this) == 0 ) { /* failed */ free(this); return 0; } /* at the moment availabe values are 0-6, but future versions may support higher levels. Internally, postproc is multiplied by 10 and values between 0 and 100 are valid */ if (this->postproc > 10) this->postproc=10; if (this->postproc < 0) this->postproc=0; #ifdef LOG printf ("divx4: this=0x%08x, decoder_ok = %d\n", this, this->decoder_ok); #endif return (video_decoder_t *) this; } /* * exported plugin catalog entry */ static uint32_t video_types[] = { /* BUF_VIDEO_MSMPEG4_V3 && this->can_handle_311 , */ /* BUF_VIDEO_MSMPEG4_V2, */ BUF_VIDEO_MPEG4, BUF_VIDEO_DIVX5, 0 }; static decoder_info_t dec_info_video = { video_types, /* supported types */ 4 /* priority */ }; plugin_info_t xine_plugin_info[] = { /* type, API, "name", version, special_info, init_function */ { PLUGIN_VIDEO_DECODER, 10, "divx4", XINE_VERSION_CODE, &dec_info_video, init_video_decoder_plugin }, { PLUGIN_NONE, 0, "", 0, NULL, NULL } };