Skip to content

V
vlc-1.1
Commit 5a8df6b0 authored by Laurent Aimar's avatar Laurent Aimar
Browse files
Options

* all: removed old encoding way.

parent ecc97852
Hide whitespace changes
Inline Side-by-side
Showing with 1 addition and 1348 deletions
Makefile.am
View file @ 5a8df6b0
......@@ -71,7 +71,6 @@ HEADERS_include = \
include/darwin_specific.h \
include/charset.h \
include/codecs.h \
include/encoder.h \
include/ninput.h \
include/input_ext-dec.h \
include/input_ext-intf.h \
......
configure.ac
View file @ 5a8df6b0
dnl Autoconf settings for vlc
dnl $Id: configure.ac,v 1.69 2003/08/27 08:27:52 gbazin Exp $
dnl $Id: configure.ac,v 1.70 2003/08/29 19:50:12 fenrir Exp $
AC_INIT(vlc,0.6.3-cvs)
......@@ -1621,11 +1621,6 @@ then
fi
fi
dnl Duplicate the ffmpeg CPPFLAGS and LDFLAGS for the encoder
AX_ADD_CPPFLAGS([encoder_ffmpeg],[${CPPFLAGS_ffmpeg}])
dnl XXX: we don't link with -lavcodec blah blah blah
dnl AX_ADD_LDFLAGS([encoder_ffmpeg],[${LDFLAGS_ffmpeg}])
ac_have_vorbis_headers=yes
AC_CHECK_HEADERS(vorbis/vorbisenc.h vorbis/codec.h,,
ac_have_vorbis_headers=no)
......@@ -1743,10 +1738,6 @@ then
LDFLAGS="${LDFLAGS_save}"
CPPFLAGS="${CPPFLAGS_save}"
fi
dnl Duplicate the xvid CPPFLAGS and LDFLAGS for the encoder
AX_ADD_LDFLAGS([encoder_xvid],[${LDFLAGS_xvid}])
AX_ADD_CPPFLAGS([encoder_xvid],[${CPPFLAGS_xvid}])
fi
dnl
......@@ -3318,8 +3309,6 @@ AC_OUTPUT([
modules/demux/mp4/Makefile
modules/demux/mpeg/Makefile
modules/demux/util/Makefile
modules/encoder/Makefile
modules/encoder/ffmpeg/Makefile
modules/gui/Makefile
modules/gui/beos/Makefile
modules/gui/pda/Makefile
......
include/encoder.h deleted 100644 → 0
View file @ ecc97852
/*****************************************************************************
* encoder.h :
*****************************************************************************
* Copyright (C) 2002 VideoLAN
* $Id: encoder.h,v 1.1 2003/01/22 10:41:57 fenrir Exp $
*
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
*
* This program 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.
*
* This program 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, USA.
*****************************************************************************/
#ifndef _ENCODER_H
#define _ENCODER_H
typedef struct encoder_sys_t encoder_sys_t;
typedef struct video_encoder_s
{
VLC_COMMON_MEMBERS
module_t * p_module;
vlc_fourcc_t i_codec; /* in */
vlc_fourcc_t i_chroma; /* in/out */
int i_width; /* in/out */
int i_height; /* in/out */
int i_aspect; /* in/out */
size_t i_buffer_size; /* in/out */
encoder_sys_t *p_sys;
int (*pf_init) ( struct video_encoder_s *p_enc );
int (*pf_encode) ( struct video_encoder_s *p_enc, picture_t *p_pic, void *p_data, size_t *pi_data );
void (*pf_end) ( struct video_encoder_s *p_enc );
} video_encoder_t;
/*
* Video decoder:
*
* = at loading a video decoder must
* * see if i_codec is supporte, if not => failling
* * modify i_width/i_height/i_chroma/i_aspect if required (for example,
* if a video codec required %8 size)
* * init/check the library
* * set pf_init, pf_encode and pf_end
* * set i_buffer_size to the max buffer size required to output a single frame
*
* = pf_init must
* * start encoding processing
* * doesn't change any parameters (i_chroma/i_width/i_height/i_aspect)
* * check for passed parameters (no one for the moment)
*
* = pf_encode must
* * encode a single frame
* * doesn't change any parameters (...)
* * doesn't look for passed paramters
*
* = pf_end must
* * end the encoding process
* * revert all that pf_init (and pf_encode) has done (memory...)
*
* = at unloading, a video decoder must revert all that was done while loading
*
* XXX: pf_init/pf_end could be called multiple time without the plugin unloaded.
* XXX: all memory allocated by video encoder MUST be unallocated by video encoder
*
*/
#endif
modules/encoder/.cvsignore deleted 100644 → 0
View file @ ecc97852
.deps
.dirstamp
*.lo
*.la
*.dll
*.dylib
*.sl
*.so
Makefile.am
Makefile.in
Makefile
modules/encoder/Modules.am deleted 100644 → 0
View file @ ecc97852
SOURCES_encoder_xvid = xvid.c
modules/encoder/ffmpeg/.cvsignore deleted 100644 → 0
View file @ ecc97852
.deps
.dirstamp
*.lo
*.la
*.dll
*.dylib
*.sl
*.so
Makefile.am
Makefile.in
Makefile
modules/encoder/ffmpeg/Modules.am deleted 100644 → 0
View file @ ecc97852
SOURCES_encoder_ffmpeg = \
encoder.c \
video.c \
audio.c \
$(NULL)
modules/encoder/ffmpeg/audio.c deleted 100644 → 0
View file @ ecc97852
/*****************************************************************************
* audio.c : audio encoder using ffmpeg library
*****************************************************************************
* Copyright (C) 2002 VideoLAN
* $Id: audio.c,v 1.2 2003/04/20 11:57:13 gbazin Exp $
*
* Authors: Laurent Aimar
*
* This program 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.
*
* This program 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, USA.
*****************************************************************************/
/*****************************************************************************
* Preamble
*****************************************************************************/
#include <vlc/vlc.h>
#include <vlc/vout.h>
#include <vlc/input.h>
#include <vlc/decoder.h>
#include <stdlib.h>
#include "codecs.h"
/* ffmpeg header */
#ifdef HAVE_FFMPEG_AVCODEC_H
# include <ffmpeg/avcodec.h>
#else
# include <avcodec.h>
#endif
/*****************************************************************************
* Local prototypes
*****************************************************************************/
int E_( OpenEncoderAudio ) ( vlc_object_t * );
void E_( CloseEncoderAudio )( vlc_object_t * );
struct encoder_sys_t
{
void *audio_handle;
};
int E_( OpenEncoderAudio ) ( vlc_object_t *p_this )
{
return VLC_EGENERIC;
}
void E_( CloseEncoderAudio )( vlc_object_t *p_this )
{
;
}
modules/encoder/ffmpeg/encoder.c deleted 100644 → 0
View file @ ecc97852
/*****************************************************************************
* encoder.c : audio/video encoder using ffmpeg library
*****************************************************************************
* Copyright (C) 2002 VideoLAN
* $Id: encoder.c,v 1.4 2003/04/27 23:16:35 gbazin Exp $
*
* Authors: Laurent Aimar
*
* This program 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.
*
* This program 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, USA.
*****************************************************************************/
/*****************************************************************************
* Preamble
*****************************************************************************/
#include <vlc/vlc.h>
#include <vlc/vout.h>
#include <vlc/input.h>
#include <vlc/decoder.h>
#include <stdlib.h>
#include "codecs.h"
#include "encoder.h"
/*****************************************************************************
* Local prototypes
*****************************************************************************/
int E_( OpenEncoderVideo )( vlc_object_t * );
void E_( CloseEncoderVideo )( vlc_object_t * );
int E_( OpenEncoderAudio ) ( vlc_object_t * );
void E_( CloseEncoderAudio )( vlc_object_t * );
/*****************************************************************************
* Module descriptor
*****************************************************************************/
vlc_module_begin();
set_description( _("ffmpeg video encoder") );
add_shortcut( "ffmpeg" );
set_capability( "video encoder", 100 );
set_callbacks( E_( OpenEncoderVideo ), E_( CloseEncoderVideo ) );
add_category_hint( "video setting", NULL, VLC_TRUE );
add_integer( "encoder-ffmpeg-video-bitrate", 1000, NULL, "bitrate (kb/s)", "bitrate (kb/s)", VLC_TRUE );
add_integer( "encoder-ffmpeg-video-max-key-interval", 10, NULL, "max key interval", "maximum value of frames between two keyframes", VLC_TRUE );
add_integer( "encoder-ffmpeg-video-min-quant", 2, NULL, "min quantizer", "range 1-31", VLC_TRUE );
add_integer( "encoder-ffmpeg-video-max-quant", 31, NULL, "max quantizer", "range 1-31", VLC_TRUE );
add_submodule();
set_description( _("ffmpeg audio encoder") );
set_capability( "audio encoder", 50 );
set_callbacks( E_( OpenEncoderAudio ), E_( CloseEncoderAudio ) );
add_category_hint( "audio setting", NULL, VLC_TRUE );
add_integer( "encoder-ffmpeg-audio-bitrate", 64, NULL, "bitrate (kb/s)", "bitrate (kb/s)", VLC_TRUE );
vlc_module_end();
modules/encoder/ffmpeg/video.c deleted 100644 → 0
View file @ ecc97852
/*****************************************************************************
* video.c : video encoder using ffmpeg library
*****************************************************************************
* Copyright (C) 2002 VideoLAN
* $Id: video.c,v 1.5 2003/07/28 20:25:30 jpsaman Exp $
*
* Authors: Laurent Aimar
*
* This program 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.
*
* This program 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, USA.
*****************************************************************************/
/*****************************************************************************
* Preamble
*****************************************************************************/
#include <vlc/vlc.h>
#include <vlc/vout.h>
#include <vlc/input.h>
#include <vlc/decoder.h>
#include <stdlib.h>
#include "codecs.h"
#include "encoder.h"
/* ffmpeg header */
#ifdef HAVE_FFMPEG_AVCODEC_H
# include <ffmpeg/avcodec.h>
#else
# include <avcodec.h>
#endif
int E_( OpenEncoderVideo ) ( vlc_object_t * );
void E_( CloseEncoderVideo )( vlc_object_t * );
/*****************************************************************************
* Local prototypes
*****************************************************************************/
static int Init ( video_encoder_t *p_encoder );
static int Encode ( video_encoder_t *p_encoder,
picture_t *p_pic, void *p_data, size_t *pi_data );
static void End ( video_encoder_t *p_encoder );
/*****************************************************************************
* Local definitions
*****************************************************************************/
struct encoder_sys_t
{
char *psz_codec;
AVCodecContext *p_context;
AVCodec *p_codec;
AVFrame *p_frame;
};
/*****************************************************************************
* OpenEncoderVideo:
*****************************************************************************
*
*****************************************************************************/
int E_( OpenEncoderVideo ) ( vlc_object_t *p_this )
{
video_encoder_t *p_encoder = (video_encoder_t*)p_this;
/* *** check supported codec *** */
switch( p_encoder->i_codec )
{
case VLC_FOURCC( 'm', 'p', '1', 'v' ):
case VLC_FOURCC( 'm', 'p', 'g', 'v' ):
case VLC_FOURCC( 'm', 'p', '4', 'v' ):
case VLC_FOURCC( 'h', 'u', 'f', 'f' ):
break;
default:
return VLC_EGENERIC;
}
/* *** init library */
avcodec_init();
avcodec_register_all();
/* *** fix parameters *** */
switch( p_encoder->i_chroma )
{
/* Planar YUV formats */
case VLC_FOURCC('I','4','4','4'):
case VLC_FOURCC('I','4','2','2'):
case VLC_FOURCC('Y','V','1','2'):
case VLC_FOURCC('I','4','2','0'):
case VLC_FOURCC('I','Y','U','V'):
case VLC_FOURCC('I','4','1','1'):
case VLC_FOURCC('I','4','1','0'):
/* Packed YUV formats */
case VLC_FOURCC('Y','U','Y','2'):
case VLC_FOURCC('U','Y','V','Y'):
/* Packed RGB formats */
case VLC_FOURCC('R','V','3','2'):
case VLC_FOURCC('R','V','2','4'):
case VLC_FOURCC('R','V','1','6'):
case VLC_FOURCC('R','V','1','5'):
case VLC_FOURCC('R','G','B','2'):
break;
default:
return VLC_EGENERIC;
}
#if 0
p_encoder->i_width = ( p_encoder->i_width + 15 )&0xfffff8;
p_encoder->i_height = ( p_encoder->i_height + 15 )&0xfffff8;
#endif
/* *** set exported functions *** */
p_encoder->pf_init = Init;
p_encoder->pf_encode = Encode;
p_encoder->pf_end = End;
return VLC_SUCCESS;
}
/*****************************************************************************
* CloseEncoderVideo:
*****************************************************************************
*
*****************************************************************************/
void E_( CloseEncoderVideo )( vlc_object_t *p_this )
{
;
}
/*****************************************************************************
* Init:
*****************************************************************************
*
*****************************************************************************/
static int Init ( video_encoder_t *p_encoder )
{
encoder_sys_t *p_sys;
int i_codec;
/* *** allocate memory *** */
if( !( p_encoder->p_sys = p_sys = malloc( sizeof( encoder_sys_t ) ) ) )
{
msg_Err( p_encoder, "out of memory" );
return VLC_EGENERIC;
}
memset( p_sys, 0, sizeof( encoder_sys_t ) );
/* *** ask for the codec *** */
switch( p_encoder->i_codec )
{
case VLC_FOURCC( 'm', 'p', '1', 'v' ):
case VLC_FOURCC( 'm', 'p', 'g', 'v' ):
p_encoder->p_sys->psz_codec = "MPEG I";
i_codec = CODEC_ID_MPEG1VIDEO;
break;
case VLC_FOURCC( 'm', 'p', '4', 'v' ):
p_encoder->p_sys->psz_codec = "MPEG-4";
i_codec = CODEC_ID_MPEG4;
break;
case VLC_FOURCC( 'h', 'u', 'f', 'f' ):
p_encoder->p_sys->psz_codec = "Huff YUV";
i_codec = CODEC_ID_HUFFYUV;
break;
default:
return VLC_EGENERIC;
}
if( ( p_sys->p_codec = avcodec_find_encoder( i_codec ) ) == NULL )
{
msg_Err( p_encoder, "cannot find encoder for %s",
p_encoder->p_sys->psz_codec );
return VLC_EGENERIC;
}
msg_Dbg( p_encoder, "encoding with %s", p_encoder->p_sys->psz_codec );
#define p_frame p_sys->p_frame
#define p_context p_sys->p_context
/* *** set context properties *** */
p_context = avcodec_alloc_context();
p_context->bit_rate = config_GetInt( p_encoder, "encoder-ffmpeg-video-bitrate" ) * 1000;
p_context->width = p_encoder->i_width;
p_context->height= p_encoder->i_height;
#if LIBAVCODEC_BUILD >= 4662
p_context->frame_rate = 25 * DEFAULT_FRAME_RATE_BASE;
#else
p_context->frame_rate = 25 * FRAME_RATE_BASE;
#endif
p_context->gop_size = config_GetInt( p_encoder, "encoder-ffmpeg-video-max-key-interval" );
p_context->qmin = __MAX( __MIN( config_GetInt( p_encoder, "encoder-ffmpeg-video-min-quant" ), 31 ), 1 );
p_context->qmax = __MAX( __MIN( config_GetInt( p_encoder, "encoder-ffmpeg-video-max-quant" ), 31 ), 1 );
if( avcodec_open( p_context, p_encoder->p_sys->p_codec ) < 0 )
{
msg_Err( p_encoder, "failed to open %s codec",
p_encoder->p_sys->psz_codec );
return VLC_EGENERIC;
}
p_frame = avcodec_alloc_frame();
switch( p_encoder->i_chroma )
{
/* Planar YUV formats */
case VLC_FOURCC('I','4','4','4'):
p_frame->pict_type = PIX_FMT_YUV444P;
break;
case VLC_FOURCC('I','4','2','2'):
p_frame->pict_type = PIX_FMT_YUV422P;
break;
case VLC_FOURCC('Y','V','1','2'):
case VLC_FOURCC('I','4','2','0'):
case VLC_FOURCC('I','Y','U','V'):
p_frame->pict_type = PIX_FMT_YUV420P;
break;
case VLC_FOURCC('I','4','1','1'):
p_frame->pict_type = PIX_FMT_YUV411P;
break;
case VLC_FOURCC('I','4','1','0'):
p_frame->pict_type = PIX_FMT_YUV410P;
break;
/* Packed YUV formats */
case VLC_FOURCC('Y','U','Y','2'):
case VLC_FOURCC('U','Y','V','Y'):
p_frame->pict_type = PIX_FMT_YUV422;
break;
/* Packed RGB formats */
case VLC_FOURCC('R','V','3','2'):
p_frame->pict_type = PIX_FMT_RGBA32;
break;
case VLC_FOURCC('R','V','2','4'):
p_frame->pict_type = PIX_FMT_RGB24;
//p_frame->pict_type = PIX_FMT_BGR24;
break;
case VLC_FOURCC('R','V','1','6'):
p_frame->pict_type = PIX_FMT_RGB565;
break;
case VLC_FOURCC('R','V','1','5'):
p_frame->pict_type = PIX_FMT_RGB555;
break;
case VLC_FOURCC('R','G','B','2'):
p_frame->pict_type = PIX_FMT_GRAY8;
break;
default:
return VLC_EGENERIC;
}
return VLC_SUCCESS;
#undef p_context
#undef p_frame
}
/*****************************************************************************
* Encode:
*****************************************************************************
*
*****************************************************************************/
static int Encode( video_encoder_t *p_encoder,
picture_t *p_pic, void *p_data, size_t *pi_data )
{
#define p_frame p_encoder->p_sys->p_frame
#define p_context p_encoder->p_sys->p_context
int i;
for( i = 0; i < p_pic->i_planes; i++ )
{
p_frame->linesize[i] = p_pic->p[i].i_pitch;
p_frame->data[i] = p_pic->p[i].p_pixels;
}
*pi_data = avcodec_encode_video( p_context, p_data, *pi_data, p_frame );
return VLC_SUCCESS;
#undef p_context
#undef p_frame
}
/*****************************************************************************
* End:
*****************************************************************************
*
*****************************************************************************/
static void End( video_encoder_t *p_encoder )
{
avcodec_close( p_encoder->p_sys->p_context );
free( p_encoder->p_sys->p_context );
p_encoder->p_sys->p_context = NULL;
p_encoder->p_sys->p_codec = NULL;
}
modules/encoder/xvid.c deleted 100644 → 0
View file @ ecc97852
/*****************************************************************************
* xvid.c: an encoder for libxvidcore, the Xvid video codec
*****************************************************************************
* Copyright (C) 2002 VideoLAN
* $Id: xvid.c,v 1.3 2003/02/22 16:10:31 fenrir Exp $
*
* Authors: Laurent Aimar
*
* This program 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.
*
* This program 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, USA.
*****************************************************************************/
/*****************************************************************************
* Preamble
*****************************************************************************/
#include <vlc/vlc.h>
#include <vlc/vout.h>
#include <vlc/input.h>
#include <vlc/decoder.h>
#include <stdlib.h>
#include "codecs.h"
#include "encoder.h"
#include <xvid.h>
/*****************************************************************************
* Local prototypes
*****************************************************************************/
static int OpenEncoder ( vlc_object_t * );
static void CloseEncoder ( vlc_object_t * );
static int Init ( video_encoder_t *p_encoder );
static int Encode ( video_encoder_t *p_encoder,
picture_t *p_pic, void *p_data, size_t *pi_data );
static void End ( video_encoder_t *p_encoder );
/*****************************************************************************
* Module descriptor
*****************************************************************************/
static char * ppsz_xvid_quant_algo[] = { "MPEG", "H263",NULL };
static char * ppsz_xvid_me[] = { "", "zero", "logarithmic", "fullsearch", "pmvfast", "epzs", NULL };
vlc_module_begin();
set_description( _("XviD video encoder (MPEG-4)") );
set_capability( "video encoder", 50 );
set_callbacks( OpenEncoder, CloseEncoder );
add_shortcut( "xvid" );
add_category_hint( "general setting", NULL, VLC_TRUE );
add_integer( "encoder-xvid-bitrate", 1000, NULL, "bitrate (kb/s)", "bitrate (kb/s)", VLC_TRUE );
add_integer( "encoder-xvid-min-quantizer", 2, NULL, "min quantizer", "range 1-31", VLC_TRUE );
add_integer( "encoder-xvid-max-quantizer", 31, NULL, "max quantizer", "1-31", VLC_TRUE );
add_integer( "encoder-xvid-max-key-interval", -1, NULL, "max key interval", "maximum value of frames between two keyframes", VLC_TRUE );
add_category_hint( "advanced setting", NULL, VLC_TRUE );
add_integer( "encoder-xvid-reaction-delay-factor", -1, NULL, "rc reaction delay factor", "rate controler parameters", VLC_TRUE);
add_integer( "encoder-xvid-averaging-period", -1, NULL, "rc averaging period", "rate controler parameters", VLC_TRUE );
add_integer( "encoder-xvid-buffer", -1, NULL, "rc buffer", "rate controler parameters", VLC_TRUE );
add_category_hint( "advanced frame setting", NULL, VLC_TRUE );
add_string_from_list( "encoder-xvid-quantization", "MPEG", ppsz_xvid_quant_algo, NULL, "quantization algorithm", "", VLC_TRUE );
add_bool( "encoder-xvid-halfpel", 1, NULL, "half pixel motion estimation.", "", VLC_TRUE );
add_bool( "encoder-xvid-4mv", 0, NULL, "fourc vector per macroblock(need halfpel)", "", VLC_TRUE );
add_bool( "encoder-xvid-lumi-mask", 0, NULL, "use a lumimasking algorithm", "", VLC_TRUE );
add_bool( "encoder-xvid-adaptive-quant", 0, NULL, "perform an adaptative quantization", "", VLC_TRUE );
add_bool( "encoder-xvid-interlacing", 0, NULL, "use MPEG4 interlaced mode", "", VLC_TRUE );
add_string_from_list( "encoder-xvid-me", "", ppsz_xvid_me, NULL, "motion estimation", "", VLC_TRUE );
add_bool( "encoder-xvid-motion-advanceddiamond", 1, NULL, "motion advanceddiamond", "", VLC_TRUE );
add_bool( "encoder-xvid-motion-halfpeldiamond", 1, NULL, "motion halfpel diamond", "", VLC_TRUE );
add_bool( "encoder-xvid-motion-halfpelrefine", 1, NULL, "motion halfpelrefine", "", VLC_TRUE );
add_bool( "encoder-xvid-motion-extsearch", 1, NULL, "motion extsearch", "", VLC_TRUE );
add_bool( "encoder-xvid-motion-earlystop", 1, NULL, "motion earlystop", "", VLC_TRUE );
add_bool( "encoder-xvid-motion-quickstop", 1, NULL, "motion quickstop", "", VLC_TRUE );
add_bool( "encoder-xvid-motion-usesquares", 0, NULL, "use a square search", "", VLC_TRUE );
vlc_module_end();
struct encoder_sys_t
{
void *handle;
XVID_ENC_FRAME xframe;
};
/*****************************************************************************
* OpenEncoder:
*****************************************************************************
* Check the library and init it
* see if it can encode to the requested codec
*****************************************************************************/
static int OpenEncoder ( vlc_object_t *p_this )
{
video_encoder_t *p_encoder = (video_encoder_t*)p_this;
XVID_INIT_PARAM xinit;
int i_err;
if( p_encoder->i_codec != VLC_FOURCC( 'm', 'p', '4', 'v' ) )
{
/* unsupported codec */
return VLC_EGENERIC;
}
msg_Dbg( p_encoder, "XviD encoder compiled for API_VERSION:0x%x", API_VERSION );
/* init the library */
xinit.cpu_flags = 0;
if( ( i_err = xvid_init( NULL, 0, &xinit, NULL ) ) != XVID_ERR_OK )
{
msg_Err( p_encoder, "cannot init xvid library (err:0x%x)", i_err );
return VLC_EGENERIC;
}
/* check API_VERSION */
if( xinit.api_version != API_VERSION )
{
msg_Err( p_encoder, "API_VERSION version mismatch (library:0x%x)", xinit.api_version );
return VLC_EGENERIC;
}
msg_Dbg( p_encoder, "XviD api_version:0x%x core_build:0x%x cpu_flags:0x%x",
xinit.api_version,
xinit.core_build,
xinit.cpu_flags );
/* force some parameters */
if( p_encoder->i_chroma != VLC_FOURCC( 'Y', 'V', '1', '2' )&&
p_encoder->i_chroma != VLC_FOURCC( 'I', '4', '2', '0' ) )
{
p_encoder->i_chroma = VLC_FOURCC( 'I', '4', '2', '0' );
}
/* set exported functions */
p_encoder->pf_init = Init;
p_encoder->pf_encode = Encode;
p_encoder->pf_end = End;
return VLC_SUCCESS;
}
static void CloseEncoder ( vlc_object_t *p_this )
{
;
}
/*****************************************************************************
* Init:
*****************************************************************************
*
*****************************************************************************/
static int Init ( video_encoder_t *p_encoder )
{
encoder_sys_t *p_sys;
char *psz;
int i_err;
XVID_ENC_PARAM xparam;
if( !( p_encoder->p_sys = p_sys = malloc( sizeof( encoder_sys_t ) ) ) )
{
msg_Err( p_encoder, "out of memory" );
return VLC_EGENERIC;
}
memset( p_sys, 0, sizeof( encoder_sys_t ) );
/* *** open a instance of the codec *** */
xparam.width = p_encoder->i_width;
xparam.height = p_encoder->i_height;
/* framerat = xparam.fbase / xparam.fincr */
xparam.fincr = 1;
xparam.fbase = 25;
/* desired bitrate */
xparam.rc_bitrate = config_GetInt( p_encoder, "encoder-xvid-bitrate" ) * 1000;
/* setting to success in achive xparam.rc_bitrate */
xparam.rc_reaction_delay_factor = config_GetInt( p_encoder, "encoder-xvid-reaction-delay-factor" );
xparam.rc_averaging_period = config_GetInt( p_encoder, "encoder-xvid-averaging-period" );
xparam.rc_buffer = config_GetInt( p_encoder, "encoder-xvid-buffer" );
/* limit the range of allowed quantizers [1..31] */
xparam.min_quantizer = config_GetInt( p_encoder, "encoder-xvid-min-quantizer" );;
xparam.min_quantizer = __MAX( __MIN( xparam.min_quantizer, 31 ), 1 );
xparam.max_quantizer = config_GetInt( p_encoder, "encoder-xvid-max-quantizer" );
xparam.max_quantizer = __MAX( __MIN( xparam.max_quantizer, 31 ), 1 );
/* maximum value of frames between two keyframes */
xparam.max_key_interval = config_GetInt( p_encoder, "encoder-xvid-max-key-interval" );
switch( xvid_encore( NULL, XVID_ENC_CREATE, &xparam, NULL ) )
{
case XVID_ERR_OK:
msg_Dbg( p_encoder, "encoder creation successed" );
break;
case XVID_ERR_MEMORY:
msg_Err( p_encoder, "encoder creation failed, out of memory" );
return VLC_EGENERIC;
case XVID_ERR_FORMAT:
msg_Err( p_encoder, "encoder creation failed, bad format" );
return VLC_EGENERIC;
case XVID_ERR_FAIL:
default:
msg_Err( p_encoder, "encoder creation failed" );
return VLC_EGENERIC;
}
/* get the handle */
p_sys->handle = xparam.handle;
/* *** set xframe parameters *** */
#define xframe p_sys->xframe
/* set xframe.general options */
xframe.general = 0;
psz = config_GetPsz( p_encoder, "encoder-xvid-quantization" );
if( psz )
{
if( !strcmp( psz, "H263" ) )
{
xframe.general |= XVID_H263QUANT;
}
else
{
xframe.general |= XVID_MPEGQUANT;
}
free( psz );
}
if( config_GetInt( p_encoder, "encoder-xvid-halfpel" ) )
xframe.general |= XVID_HALFPEL;
if( config_GetInt( p_encoder, "encoder-xvid-4mv" ) )
xframe.general |= XVID_INTER4V;
if( config_GetInt( p_encoder, "encoder-xvid-lumi-mask" ) )
xframe.general |= XVID_LUMIMASKING;
if( config_GetInt( p_encoder, "encoder-xvid-adaptive-quant" ) )
xframe.general |= XVID_ADAPTIVEQUANT;
if( config_GetInt( p_encoder, "encoder-xvid-interlacing" ) )
xframe.general |= XVID_INTERLACING;
psz = config_GetPsz( p_encoder, "encoder-xvid-me" );
if( psz )
{
if( !strcmp( psz, "zero" ) )
{
xframe.general |= XVID_ME_ZERO;
}
else if( !strcmp( psz, "logarithmic" ) )
{
xframe.general |= XVID_ME_LOGARITHMIC;
}
else if( !strcmp( psz, "fullsearch" ) )
{
xframe.general |= XVID_ME_FULLSEARCH;
}
else if( !strcmp( psz, "pmvfast" ) )
{
xframe.general |= XVID_ME_PMVFAST;
}
else if( !strcmp( psz, "epzs" ) )
{
xframe.general |= XVID_ME_EPZS;
}
free( psz );
}
xframe.motion = 0;
if( config_GetInt( p_encoder, "encoder-xvid-motion-advanceddiamond" ) )
xframe.motion |= PMV_ADVANCEDDIAMOND16 | PMV_ADVANCEDDIAMOND8;
if( config_GetInt( p_encoder, "encoder-xvid-motion-halfpeldiamond" ) )
xframe.motion |= PMV_HALFPELDIAMOND16 | PMV_HALFPELDIAMOND8;
if( config_GetInt( p_encoder, "encoder-xvid-motion-halfpelrefine") )
xframe.motion |= PMV_HALFPELREFINE16 | PMV_HALFPELREFINE8;
if( config_GetInt( p_encoder, "encoder-xvid-motion-extsearch" ) )
xframe.motion |= PMV_EXTSEARCH16 | PMV_EXTSEARCH8;
if( config_GetInt( p_encoder, "encoder-xvid-motion-earlystop") )
xframe.motion |= PMV_EARLYSTOP16 | PMV_EARLYSTOP8;
if( config_GetInt( p_encoder, "encoder-xvid-motion-quickstop" ) )
xframe.motion |= PMV_QUICKSTOP16 | PMV_QUICKSTOP8;
if( config_GetInt( p_encoder, "encoder-xvid-motion-usesquares" ) )
xframe.motion |= PMV_USESQUARES16 | PMV_USESQUARES8;
/* no user quant matrix */
xframe.quant_intra_matrix = NULL;
xframe.quant_inter_matrix = NULL;
switch( p_encoder->i_chroma )
{
case VLC_FOURCC( 'Y', 'V', '1', '2' ):
xframe.colorspace = XVID_CSP_YV12;
case VLC_FOURCC( 'I', '4', '2', '0' ):
xframe.colorspace = XVID_CSP_I420;
}
/* != 0 -> force quant */
xframe.quant = 0;
#undef xframe
return VLC_SUCCESS;
}
/*****************************************************************************
* Encode: encode a single frame
*****************************************************************************
*
*****************************************************************************/
static int Encode ( video_encoder_t *p_encoder,
picture_t *p_pic, void *p_data, size_t *pi_data )
{
int i_err;
#define xframe p_encoder->p_sys->xframe
xframe.image = p_pic->p->p_pixels;
xframe.bitstream = p_data;
xframe.length = -1;
/* let codec decided between I-frame and P-frame */
xframe.intra = -1;
i_err = xvid_encore( p_encoder->p_sys->handle, XVID_ENC_ENCODE, &xframe, NULL );
*pi_data = xframe.length;
#undef xframe
return VLC_SUCCESS;
}
/*****************************************************************************
* End
*****************************************************************************
*
*****************************************************************************/
static void End ( video_encoder_t *p_encoder )
{
int i_err;
/* *** close the codec */
i_err = xvid_encore(p_encoder->p_sys->handle, XVID_ENC_DESTROY, NULL, NULL);
/* *** free memory */
free( p_encoder->p_sys );
msg_Dbg( p_encoder, "closing encoder (err:0x%x)", i_err );
return;
}
modules/video_output/encoder.c deleted 100644 → 0
View file @ ecc97852
/*****************************************************************************
* encoder.c : encoder wrapper plugin for vlc
*****************************************************************************
* Copyright (C) 2002 VideoLAN
* $Id: encoder.c,v 1.3 2003/03/30 18:14:38 gbazin Exp $
*
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
*
* This program 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.
*
* This program 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, USA.
*****************************************************************************/
/*****************************************************************************
* Preamble
*****************************************************************************/
#include <stdlib.h>
#include <vlc/vlc.h>
#include <vlc/vout.h>
#include <vlc/input.h>
#include "encoder.h"
/*****************************************************************************
* Local prototypes
*****************************************************************************/
static int Create ( vlc_object_t * );
static void Destroy ( vlc_object_t * );
static int Init ( vout_thread_t * );
static void End ( vout_thread_t * );
static int Manage ( vout_thread_t * );
static void Render ( vout_thread_t *, picture_t * );
static void Display ( vout_thread_t *, picture_t * );
static void SetPalette( vout_thread_t *, uint16_t *, uint16_t *, uint16_t * );
/*****************************************************************************
* Module descriptor
*****************************************************************************/
vlc_module_begin();
set_description( _("Encoder wrapper") );
set_capability( "video output", 0 );
set_callbacks( Create, Destroy );
add_shortcut( "encoder" );
vlc_module_end();
/*****************************************************************************
* vout_sys_t: video output descriptor
*****************************************************************************
* This structure is part of the video output thread descriptor.
* It describes the SVGAlib specific properties of an output thread.
*****************************************************************************/
struct vout_sys_t
{
vlc_fourcc_t i_codec;
video_encoder_t *p_encoder;
int i_buffer;
void *p_buffer;
input_thread_t *p_input;
es_descriptor_t *p_es;
};
/*****************************************************************************
* Create: allocates video thread
*****************************************************************************
* This function allocates and initializes a vout method.
*****************************************************************************/
static int Create( vlc_object_t *p_this )
{
vout_thread_t *p_vout = (vout_thread_t *)p_this;
char *psz_sout;
char *psz_sout_vcodec;
vlc_fourcc_t i_codec;
psz_sout = config_GetPsz( p_vout, "sout" );
if( !psz_sout || !*psz_sout )
{
/* avoid bad infinite loop */
msg_Err( p_vout, "encoder video output should be used only in sout mode" );
if( psz_sout ) free( psz_sout );
return VLC_EGENERIC;
}
free( psz_sout );
psz_sout_vcodec = config_GetPsz( p_vout, "sout-vcodec" );
if( !psz_sout_vcodec || !*psz_sout_vcodec )
{
msg_Err( p_vout, "you have to specify a video codec using sout-vcodec" );
if( psz_sout_vcodec ) free( psz_sout_vcodec );
return VLC_EGENERIC;
}
if( !strcmp( psz_sout_vcodec, "mpeg4" ) )
{
i_codec = VLC_FOURCC( 'm', 'p', '4', 'v' );
}
else if( !strcmp( psz_sout_vcodec, "mpeg2" ) )
{
i_codec = VLC_FOURCC( 'm', 'p', '2', 'v' );
}
else if( !strcmp( psz_sout_vcodec, "mpeg1" ) )
{
i_codec = VLC_FOURCC( 'm', 'p', '1', 'v' );
}
else
{
int i;
int c[4];
msg_Warn( p_vout, "unknown codec %s used as a fourcc", psz_sout_vcodec );
for( i = 0; i < 4; i++ )
{
if( psz_sout_vcodec[i] )
c[i] = psz_sout_vcodec[i];
else
c[i] = ' ';
}
i_codec = VLC_FOURCC( c[0], c[1], c[2], c[3] );
}
free( psz_sout_vcodec );
/* Allocate instance and initialize some members */
if( !( p_vout->p_sys = malloc( sizeof( vout_sys_t ) ) ) )
{
return VLC_ENOMEM;
}
memset( p_vout->p_sys, 0, sizeof( vout_sys_t ) );
/* *** save parameters *** */
p_vout->p_sys->i_codec = i_codec;
/* *** set exported functions *** */
p_vout->pf_init = Init;
p_vout->pf_end = End;
p_vout->pf_render = Render;
p_vout->pf_manage = Manage;
p_vout->pf_display = Display;
return VLC_SUCCESS;
}
/*****************************************************************************
* Init: initialize video thread
*****************************************************************************/
static int Init( vout_thread_t *p_vout )
{
vout_sys_t *p_sys = p_vout->p_sys;
video_encoder_t *p_encoder = p_vout->p_sys->p_encoder;
char *psz_sout_vcodec;
int i_index;
picture_t *p_pic;
/* *** create a video encoder object *** */
p_vout->p_sys->p_encoder =
p_encoder = vlc_object_create( p_vout, sizeof( video_encoder_t ) );
/* *** set wanted input format *** */
p_encoder->i_codec = p_vout->p_sys->i_codec;
/* *** set preferred properties *** */
/* encoder can modify all these values except i_codec */
p_encoder->i_chroma = p_vout->render.i_chroma;
p_encoder->i_width = p_vout->render.i_width;
p_encoder->i_height = p_vout->render.i_height;
p_encoder->i_aspect = p_vout->render.i_aspect;
p_encoder->i_buffer_size = 0;
/* *** requuest this module *** */
p_encoder->p_module = module_Need( p_encoder,
"video encoder",
"$video-encoder" );
if( !p_encoder->p_module )
{
msg_Warn( p_vout,
"no suitable encoder to %4.4s",
(char*)&p_encoder->i_codec );
vlc_object_destroy( p_encoder );
return VLC_EGENERIC;
}
/* *** init the codec *** */
if( p_encoder->pf_init( p_encoder ) )
{
msg_Err( p_vout, "failed to initialize video encoder plugin" );
vlc_object_destroy( p_encoder );
return VLC_EGENERIC;
}
/* *** alloacted buffer *** */
if( p_encoder->i_buffer_size <= 0 )
{
p_encoder->i_buffer_size = 10 * p_encoder->i_width * p_encoder->i_height;
}
p_sys->i_buffer = p_encoder->i_buffer_size;
if( !( p_sys->p_buffer = malloc( p_encoder->i_buffer_size ) ) )
{
msg_Err( p_vout, "out of memory" );
return VLC_ENOMEM;
}
/* *** create a new standalone ES *** */
/* find a p_input */
p_sys->p_input = vlc_object_find( p_vout, VLC_OBJECT_INPUT, FIND_ANYWHERE );
if( !p_sys->p_input )
{
msg_Err( p_vout, "cannot find p_input" );
return VLC_EGENERIC;
}
vlc_mutex_lock( &p_sys->p_input->stream.stream_lock );
/* avoid bad loop (else output will also be reencoded until it segfault :p*/
/* XXX do it after the lock (if we have multiple video stream...) */
psz_sout_vcodec = config_GetPsz( p_vout, "sout-vcodec" );
config_PutPsz( p_vout, "sout-vcodec", NULL );
/* add a new stream */
p_sys->p_es = input_AddES( p_sys->p_input,
NULL, /* we aren't attached to a program */
12, /* es_id */
0 ); /* no extra data */
if( !p_sys->p_es )
{
msg_Err( p_vout, "cannot create es" );
vlc_mutex_unlock( &p_sys->p_input->stream.stream_lock );
return VLC_EGENERIC;
}
p_sys->p_es->i_stream_id = 1;
p_sys->p_es->i_fourcc = p_encoder->i_codec;
p_sys->p_es->i_cat = VIDEO_ES;
if( input_SelectES( p_sys->p_input, p_sys->p_es ) )
{
input_DelES( p_sys->p_input, p_sys->p_es );
vlc_mutex_unlock( &p_sys->p_input->stream.stream_lock );
msg_Err( p_vout, "cannot select es" );
return VLC_EGENERIC;
}
/* restore value as we could have multiple video stream (have you a 42*12 GHz ?) */
config_PutPsz( p_vout, "sout-vcodec", psz_sout_vcodec );
vlc_mutex_unlock( &p_sys->p_input->stream.stream_lock );
I_OUTPUTPICTURES = 0;
p_vout->output.pf_setpalette = SetPalette;
/* remember that this value could have been modified by encoder */
p_vout->output.i_chroma = p_vout->p_sys->p_encoder->i_chroma;
p_vout->output.i_width = p_vout->p_sys->p_encoder->i_width;
p_vout->output.i_height = p_vout->p_sys->p_encoder->i_height;
p_vout->output.i_aspect = p_vout->p_sys->p_encoder->i_aspect;
/* Try to initialize 1 direct buffer */
p_pic = NULL;
/* Find an empty picture slot */
for( i_index = 0 ; i_index < VOUT_MAX_PICTURES ; i_index++ )
{
if( p_vout->p_picture[ i_index ].i_status == FREE_PICTURE )
{
p_pic = p_vout->p_picture + i_index;
break;
}
}
/* Allocate the picture */
if( p_pic == NULL )
{
return VLC_SUCCESS;
}
vout_AllocatePicture( p_vout, p_pic, p_vout->output.i_width,
p_vout->output.i_height,
p_vout->output.i_chroma );
if( p_pic->i_planes == 0 )
{
return VLC_SUCCESS;
}
p_pic->i_status = DESTROYED_PICTURE;
p_pic->i_type = DIRECT_PICTURE;
PP_OUTPUTPICTURE[ I_OUTPUTPICTURES ] = p_pic;
I_OUTPUTPICTURES++;
return VLC_SUCCESS;
}
/*****************************************************************************
* End: terminate video thread
*****************************************************************************/
static void End( vout_thread_t *p_vout )
{
vout_sys_t *p_sys = p_vout->p_sys;
video_encoder_t *p_encoder = p_vout->p_sys->p_encoder;
/* *** stop encoder *** */
p_encoder->pf_end( p_encoder );
vlc_object_release( p_sys->p_input );
/* *** unload encoder plugin *** */
module_Unneed( p_encoder,
p_encoder->p_module );
vlc_object_destroy( p_encoder );
free( p_sys->p_buffer );
}
/*****************************************************************************
* Destroy: destroy video thread
*****************************************************************************
* Terminate an output method created by Create
*****************************************************************************/
static void Destroy( vlc_object_t *p_this )
{
vout_thread_t *p_vout = (vout_thread_t *)p_this;
/* Destroy structure */
free( p_vout->p_sys );
p_vout->p_sys = NULL;
}
/*****************************************************************************
* Manage: handle events
*****************************************************************************
* This function should be called regularly by video output thread. It manages
* console events. It returns a non null value on error.
*****************************************************************************/
static int Manage( vout_thread_t *p_vout )
{
return VLC_SUCCESS;
}
/*****************************************************************************
* Render:
*****************************************************************************
*
*****************************************************************************/
static void Render( vout_thread_t *p_vout, picture_t *p_pic )
{
}
/*****************************************************************************
* Display: displays previously rendered output
*****************************************************************************
* This function sends the currently rendered image to the VGA card.
*****************************************************************************/
static void Display( vout_thread_t *p_vout, picture_t *p_pic )
{
vout_sys_t *p_sys = p_vout->p_sys;
video_encoder_t *p_encoder = p_vout->p_sys->p_encoder;
int i_err;
size_t i_data;
i_data = p_sys->i_buffer;
i_err = p_encoder->pf_encode( p_encoder,
p_pic,
p_sys->p_buffer,
&i_data );
if( i_err )
{
msg_Err( p_vout, "failed to encode a frame (err:0x%x)", i_err );
return;
}
if( i_data > 0 && p_sys->p_es->p_decoder_fifo )
{
pes_packet_t *p_pes;
data_packet_t *p_data;
if( !( p_pes = input_NewPES( p_sys->p_input->p_method_data ) ) )
{
msg_Err( p_vout, "cannot allocate new PES" );
return;
}
if( !( p_data = input_NewPacket( p_sys->p_input->p_method_data, i_data ) ) )
{
msg_Err( p_vout, "cannot allocate new data_packet" );
return;
}
p_pes->i_dts = p_pic->date;
p_pes->i_pts = p_pic->date;
p_pes->p_first = p_pes->p_last = p_data;
p_pes->i_nb_data = 1;
p_pes->i_pes_size = i_data;
p_vout->p_vlc->pf_memcpy( p_data->p_payload_start,
p_sys->p_buffer,
i_data );
input_DecodePES( p_sys->p_es->p_decoder_fifo, p_pes );
}
}
/*****************************************************************************
* SetPalette: set a 8bpp palette
*****************************************************************************
* TODO: support 8 bits clut (for Mach32 cards and others).
*****************************************************************************/
static void SetPalette( vout_thread_t *p_vout, uint16_t *red, uint16_t *green, uint16_t *blue )
{
;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment