Skip to content

V
vlc-gpu
Commit f2c55479 authored by Gildas Bazin's avatar Gildas Bazin
Browse files
Options

* modules/codec/ffmpeg/video_filter.c, include/vlc_filter.h: 

  - chroma + resizing video filter (using the filter_t architecture).
* modules/codec/ffmpeg/*:
  - cleanup + small updates.
* modules/codec/speex.c, theora.c, vorbis.c:
  - got rid of pf_header() in the encoder.
  - store the headers in fmt_out.p_extra (this will break the ogg muxer for now).
* modules/codec/libmpeg2.c, modules/codec/ffmpeg/video.c:
  - added a p_dec->b_pace_control field to signal if the decoder is allowed to drop frames.
* modules/stream_out/transcode.c:
  - heavy cleanup.
  - re-use video decoder modules and got rid of the duplicated ffmpeg video decoder.
  - use video filters for chroma conversion and resizing.
  (a few things are broken now like deinterlacing but I'll repair them asap).
parent 881b68a0
Show whitespace changes
Inline Side-by-side
Showing with 974 additions and 1274 deletions
include/vlc_codec.h
View file @ f2c55479
......@@ -46,20 +46,23 @@ struct decoder_t
module_t * p_module;
decoder_sys_t * p_sys;
picture_t * ( * pf_decode_video )( decoder_t *, block_t ** );
aout_buffer_t * ( * pf_decode_audio )( decoder_t *, block_t ** );
subpicture_t * ( * pf_decode_sub) ( decoder_t *, block_t ** );
block_t * ( * pf_packetize ) ( decoder_t *, block_t ** );
/* Some decoders only accept packetized data (ie. not truncated) */
vlc_bool_t b_need_packetized;
/* Input format ie from demuxer (XXX: a lot of field could be invalid) */
es_format_t fmt_in;
/* Output format of decoder/packetizer */
es_format_t fmt_out;
/* Some decoders only accept packetized data (ie. not truncated) */
vlc_bool_t b_need_packetized;
/* Tell the decoder if it is allowed to drop frames */
vlc_bool_t b_pace_control;
picture_t * ( * pf_decode_video )( decoder_t *, block_t ** );
aout_buffer_t * ( * pf_decode_audio )( decoder_t *, block_t ** );
subpicture_t * ( * pf_decode_sub) ( decoder_t *, block_t ** );
block_t * ( * pf_packetize ) ( decoder_t *, block_t ** );
/*
* Buffers allocation
*/
......@@ -102,17 +105,16 @@ struct encoder_t
module_t * p_module;
encoder_sys_t * p_sys;
block_t * ( * pf_header )( encoder_t * );
block_t * ( * pf_encode_video )( encoder_t *, picture_t * );
block_t * ( * pf_encode_audio )( encoder_t *, aout_buffer_t * );
block_t * ( * pf_encode_sub )( encoder_t *, subpicture_t * );
/* Properties of the input data fed to the encoder */
es_format_t fmt_in;
/* Properties of the output of the encoder */
es_format_t fmt_out;
block_t * ( * pf_encode_video )( encoder_t *, picture_t * );
block_t * ( * pf_encode_audio )( encoder_t *, aout_buffer_t * );
block_t * ( * pf_encode_sub )( encoder_t *, subpicture_t * );
/* Common encoder options */
int i_threads; /* Number of threads to use during encoding */
int i_iframes; /* One I frame per i_iframes */
......
include/vlc_filter.h
View file @ f2c55479
......@@ -45,6 +45,12 @@ struct filter_t
module_t * p_module;
filter_sys_t * p_sys;
/* Input format */
es_format_t fmt_in;
/* Output format of filter */
es_format_t fmt_out;
void ( * pf_video_blend ) ( filter_t *, picture_t *,
picture_t *, picture_t *,
int, int );
......@@ -52,12 +58,6 @@ struct filter_t
subpicture_t * ( *pf_render_string ) ( filter_t *, block_t * );
/* Input format */
es_format_t fmt_in;
/* Output format of filter */
es_format_t fmt_out;
/*
* Buffers allocation
*/
......
include/vlc_objects.h
View file @ f2c55479
......@@ -53,6 +53,7 @@
#define VLC_OBJECT_ACCESS (-19)
#define VLC_OBJECT_STREAM (-20)
#define VLC_OBJECT_OPENGL (-21)
#define VLC_OBJECT_FILTER (-22)
#define VLC_OBJECT_GENERIC (-666)
......
include/vlc_video.h
View file @ f2c55479
......@@ -106,6 +106,9 @@ struct picture_t
/** Private data - the video output plugin might want to put stuff here to
* keep track of the picture */
picture_sys_t * p_sys;
/** This way the picture_Release can be overloaded */
void (*pf_release)( picture_t * );
};
/**
......
modules/codec/ffmpeg/Modules.am
View file @ f2c55479
......@@ -3,6 +3,7 @@ SOURCES_ffmpeg = \
ffmpeg.h \
video.c \
audio.c \
video_filter.c \
chroma.c \
encoder.c \
postprocess.c \
......@@ -14,6 +15,7 @@ SOURCES_ffmpegaltivec = \
ffmpeg.h \
video.c \
audio.c \
video_filter.c \
chroma.c \
encoder.c \
postprocess.c \
......
modules/codec/ffmpeg/chroma.c
View file @ f2c55479
......@@ -4,7 +4,7 @@
* Copyright (C) 1999-2001 VideoLAN
* $Id$
*
* Authors: Gildas Bazin <gbazin@netcourrier.com>
* Authors: Gildas Bazin <gbazin@videolan.org>
*
* 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
......@@ -72,67 +72,8 @@ int E_(OpenChroma)( vlc_object_t *p_this )
i_vlc_chroma[1] = p_vout->output.i_chroma;
for( i = 0; i < 2; i++ )
{
switch( i_vlc_chroma[i] )
{
/* Planar YUV formats */
case VLC_FOURCC('I','4','4','4'):
i_ffmpeg_chroma[i] = PIX_FMT_YUV444P;
break;
case VLC_FOURCC('I','4','2','2'):
i_ffmpeg_chroma[i] = 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'):
i_ffmpeg_chroma[i] = PIX_FMT_YUV420P;
break;
case VLC_FOURCC('I','4','1','1'):
i_ffmpeg_chroma[i] = PIX_FMT_YUV411P;
break;
case VLC_FOURCC('I','4','1','0'):
case VLC_FOURCC('Y','V','U','9'):
i_ffmpeg_chroma[i] = PIX_FMT_YUV410P;
break;
/* Packed YUV formats */
case VLC_FOURCC('Y','U','Y','2'):
case VLC_FOURCC('U','Y','V','Y'):
i_ffmpeg_chroma[i] = PIX_FMT_YUV422;
break;
/* Packed RGB formats */
case VLC_FOURCC('R','V','3','2'):
i_ffmpeg_chroma[i] = PIX_FMT_RGBA32;
break;
case VLC_FOURCC('R','V','2','4'):
i_ffmpeg_chroma[i] = PIX_FMT_RGB24;
//i_ffmpeg_chroma[i] = PIX_FMT_BGR24;
break;
case VLC_FOURCC('R','V','1','6'):
i_ffmpeg_chroma[i] = PIX_FMT_RGB565;
break;
case VLC_FOURCC('R','V','1','5'):
i_ffmpeg_chroma[i] = PIX_FMT_RGB555;
break;
case VLC_FOURCC('R','G','B','2'):
i_ffmpeg_chroma[i] = PIX_FMT_GRAY8;
break;
default:
return VLC_EGENERIC;
break;
}
i_ffmpeg_chroma[i] = E_(GetFfmpegChroma)( i_vlc_chroma[i] );
if( i_ffmpeg_chroma[i] < 0 ) return VLC_EGENERIC;
}
p_vout->chroma.pf_convert = ChromaConversion;
......
modules/codec/ffmpeg/ffmpeg.c
View file @ f2c55479
......@@ -5,7 +5,7 @@
* $Id$
*
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
* Gildas Bazin <gbazin@netcourrier.com>
* Gildas Bazin <gbazin@videolan.org>
*
* 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
......@@ -160,9 +160,15 @@ vlc_module_begin();
/* demux submodule */
add_submodule();
set_description( _("ffmpeg demuxer" ) );
set_capability( "demux2", 1 );
set_capability( "demux2", 2 );
set_callbacks( E_(OpenDemux), E_(CloseDemux) );
/* video filter submodule */
add_submodule();
set_capability( "video filter2", 50 );
set_callbacks( E_(OpenFilter), E_(CloseFilter) );
set_description( _("ffmpeg video filter") );
var_Create( p_module->p_libvlc, "avcodec", VLC_VAR_MUTEX );
vlc_module_end();
......@@ -283,33 +289,6 @@ static void CloseDecoder( vlc_object_t *p_this )
/*****************************************************************************
* local Functions
*****************************************************************************/
int E_(GetFfmpegChroma)( vlc_fourcc_t i_chroma )
{
switch( i_chroma )
{
case VLC_FOURCC( 'I', '4', '2', '0' ):
return PIX_FMT_YUV420P;
case VLC_FOURCC( 'I', '4', '2', '2' ):
return PIX_FMT_YUV422P;
case VLC_FOURCC( 'I', '4', '4', '4' ):
return PIX_FMT_YUV444P;
case VLC_FOURCC( 'R', 'V', '1', '5' ):
return PIX_FMT_RGB555;
case VLC_FOURCC( 'R', 'V', '1', '6' ):
return PIX_FMT_RGB565;
case VLC_FOURCC( 'R', 'V', '2', '4' ):
return PIX_FMT_RGB24;
case VLC_FOURCC( 'R', 'V', '3', '2' ):
return PIX_FMT_RGBA32;
case VLC_FOURCC( 'G', 'R', 'E', 'Y' ):
return PIX_FMT_GRAY8;
case VLC_FOURCC( 'Y', 'U', 'Y', '2' ):
return PIX_FMT_YUV422;
default:
return -1;
}
}
void E_(InitLibavcodec)( vlc_object_t *p_object )
{
static int b_ffmpeginit = 0;
......@@ -336,7 +315,67 @@ void E_(InitLibavcodec)( vlc_object_t *p_object )
vlc_mutex_unlock( lockval.p_address );
}
/*****************************************************************************
* Chroma fourcc -> ffmpeg_id mapping
*****************************************************************************/
static struct
{
vlc_fourcc_t i_chroma;
int i_chroma_id;
} chroma_table[] =
{
/* Planar YUV formats */
{ VLC_FOURCC('I','4','4','4'), PIX_FMT_YUV444P },
{ VLC_FOURCC('I','4','2','2'), PIX_FMT_YUV422P },
{ VLC_FOURCC('I','4','2','0'), PIX_FMT_YUV420P },
{ VLC_FOURCC('Y','V','1','2'), PIX_FMT_YUV420P },
{ VLC_FOURCC('I','Y','U','V'), PIX_FMT_YUV420P },
{ VLC_FOURCC('I','4','1','1'), PIX_FMT_YUV411P },
{ VLC_FOURCC('I','4','1','0'), PIX_FMT_YUV410P },
{ VLC_FOURCC('Y','V','U','9'), PIX_FMT_YUV410P },
/* Packed YUV formats */
{ VLC_FOURCC('Y','U','Y','2'), PIX_FMT_YUV422 },
{ VLC_FOURCC('U','Y','V','Y'), PIX_FMT_YUV422 },
/* Packed RGB formats */
{ VLC_FOURCC('R','V','1','5'), PIX_FMT_RGB555 },
{ VLC_FOURCC('R','V','1','6'), PIX_FMT_RGB565 },
{ VLC_FOURCC('R','V','2','4'), PIX_FMT_RGB24 },
{ VLC_FOURCC('R','V','3','2'), PIX_FMT_RGBA32 },
{ VLC_FOURCC('G','R','E','Y'), PIX_FMT_GRAY8 },
{0}
};
int E_(GetFfmpegChroma)( vlc_fourcc_t i_chroma )
{
int i;
for( i = 0; chroma_table[i].i_chroma != 0; i++ )
{
if( chroma_table[i].i_chroma == i_chroma )
return chroma_table[i].i_chroma_id;
}
return -1;
}
vlc_fourcc_t E_(GetVlcChroma)( int i_ffmpeg_chroma )
{
int i;
for( i = 0; chroma_table[i].i_chroma != 0; i++ )
{
if( chroma_table[i].i_chroma_id == i_ffmpeg_chroma )
return chroma_table[i].i_chroma;
}
return 0;
}
/*****************************************************************************
* Codec fourcc -> ffmpeg_id mapping
*****************************************************************************/
static struct
{
vlc_fourcc_t i_fourcc;
......
modules/codec/ffmpeg/ffmpeg.h
View file @ f2c55479
......@@ -38,6 +38,7 @@ void E_(InitLibavcodec)( vlc_object_t * );
int E_(GetFfmpegCodec) ( vlc_fourcc_t, int *, int *, char ** );
int E_(GetVlcFourcc) ( int, int *, vlc_fourcc_t *, char ** );
int E_(GetFfmpegChroma)( vlc_fourcc_t );
vlc_fourcc_t E_(GetVlcChroma)( int );
/* Video decoder module */
int E_( InitVideoDec )( decoder_t *, AVCodecContext *, AVCodec *,
......@@ -67,6 +68,10 @@ void E_(CloseAudioEncoder)( vlc_object_t * );
int E_(OpenDemux) ( vlc_object_t * );
void E_(CloseDemux)( vlc_object_t * );
/* Video filter module */
int E_(OpenFilter)( vlc_object_t * );
void E_(CloseFilter)( vlc_object_t * );
/* Postprocessing module */
void *E_(OpenPostproc)( decoder_t *, vlc_bool_t * );
int E_(InitPostproc)( decoder_t *, void *, int, int, int );
......
modules/codec/ffmpeg/video.c
View file @ f2c55479
......@@ -428,7 +428,7 @@ picture_t *E_(DecodeVideo)( decoder_t *p_dec, block_t **pp_block )
return NULL;
}
if( p_sys->i_late_frames > 0 &&
if( !p_dec->b_pace_control && p_sys->i_late_frames > 0 &&
mdate() - p_sys->i_late_frames_start > I64C(5000000) )
{
if( p_sys->i_pts )
......@@ -453,7 +453,8 @@ picture_t *E_(DecodeVideo)( decoder_t *p_dec, block_t **pp_block )
/* TODO implement it in a better way */
/* A good idea could be to decode all I pictures and see for the other */
if( p_sys->b_hurry_up && p_sys->i_late_frames > 4 )
if( !p_dec->b_pace_control &&
p_sys->b_hurry_up && p_sys->i_late_frames > 4 )
{
b_drawpicture = 0;
if( p_sys->i_late_frames < 8 )
......@@ -622,6 +623,13 @@ picture_t *E_(DecodeVideo)( decoder_t *p_dec, block_t **pp_block )
p_sys->b_first_frame = VLC_FALSE;
p_pic->b_force = VLC_TRUE;
}
p_pic->i_nb_fields = p_sys->p_ff_pic->repeat_pict;
#if LIBAVCODEC_BUILD >= 4685
p_pic->b_progressive = !p_sys->p_ff_pic->interlaced_frame;
p_pic->b_top_field_first = p_sys->p_ff_pic->top_field_first;
#endif
return p_pic;
}
else
......
modules/codec/ffmpeg/video_filter.c 0 → 100644
View file @ f2c55479
/*****************************************************************************
* video filter: video filter doing chroma conversion and resizing
* using the ffmpeg library
*****************************************************************************
* Copyright (C) 1999-2001 VideoLAN
* $Id: chroma.c 7834 2004-05-30 16:57:55Z sigmunau $
*
* Authors: Gildas Bazin <gbazin@videolan.org>
*
* 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/decoder.h>
#include "vlc_filter.h"
/* ffmpeg header */
#ifdef HAVE_FFMPEG_AVCODEC_H
# include <ffmpeg/avcodec.h>
#else
# include <avcodec.h>
#endif
#include "ffmpeg.h"
void E_(InitLibavcodec) ( vlc_object_t *p_object );
static picture_t *Process( filter_t *p_filter, picture_t *p_pic );
/*****************************************************************************
* filter_sys_t : filter descriptor
*****************************************************************************/
struct filter_sys_t
{
vlc_bool_t b_resize;
vlc_bool_t b_convert;
es_format_t fmt_in;
int i_src_ffmpeg_chroma;
es_format_t fmt_out;
int i_dst_ffmpeg_chroma;
AVPicture tmp_pic;
ImgReSampleContext *p_rsc;
};
/*****************************************************************************
* OpenFilter: probe the filter and return score
*****************************************************************************/
int E_(OpenFilter)( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t*)p_this;
filter_sys_t *p_sys;
vlc_bool_t b_convert, b_resize;
ImgReSampleContext *p_rsc;
/* Check if we can handle that formats */
if( E_(GetFfmpegChroma)( p_filter->fmt_in.video.i_chroma ) < 0 ||
E_(GetFfmpegChroma)( p_filter->fmt_out.video.i_chroma ) < 0 )
{
return VLC_EGENERIC;
}
b_resize =
p_filter->fmt_in.video.i_width != p_filter->fmt_out.video.i_width ||
p_filter->fmt_in.video.i_height != p_filter->fmt_out.video.i_height;
b_convert =
p_filter->fmt_in.video.i_chroma != p_filter->fmt_out.video.i_chroma;
if( !b_resize && !b_convert )
{
/* Nothing to do */
return VLC_EGENERIC;
}
p_rsc = img_resample_init( p_filter->fmt_out.video.i_width,
p_filter->fmt_out.video.i_height,
p_filter->fmt_in.video.i_width,
p_filter->fmt_in.video.i_height );
if( !p_rsc )
{
msg_Err( p_filter, "img_resample_init failed" );
return VLC_EGENERIC;
}
/* Allocate the memory needed to store the decoder's structure */
if( ( p_filter->p_sys = p_sys =
(filter_sys_t *)malloc(sizeof(filter_sys_t)) ) == NULL )
{
msg_Err( p_filter, "out of memory" );
return VLC_EGENERIC;
}
/* Misc init */
p_sys->b_resize = b_resize;
p_sys->b_convert = b_convert;
p_sys->p_rsc = p_rsc;
p_sys->i_src_ffmpeg_chroma =
E_(GetFfmpegChroma)( p_filter->fmt_in.video.i_chroma );
p_sys->i_dst_ffmpeg_chroma =
E_(GetFfmpegChroma)( p_filter->fmt_out.video.i_chroma );
p_sys->fmt_in = p_filter->fmt_in;
p_sys->fmt_out = p_filter->fmt_out;
p_filter->pf_video_filter = Process;
avpicture_alloc( &p_sys->tmp_pic, p_sys->i_dst_ffmpeg_chroma,
p_filter->fmt_in.video.i_width,
p_filter->fmt_in.video.i_height );
msg_Dbg( p_filter, "input: %ix%i %4.4s -> %ix%i %4.4s",
p_filter->fmt_in.video.i_width, p_filter->fmt_in.video.i_height,
(char *)&p_filter->fmt_in.video.i_chroma,
p_filter->fmt_out.video.i_width, p_filter->fmt_out.video.i_height,
(char *)&p_filter->fmt_out.video.i_chroma );
/* libavcodec needs to be initialized for some chroma conversions */
E_(InitLibavcodec)(p_this);
return VLC_SUCCESS;
}
/*****************************************************************************
* CloseFilter: clean up the filter
*****************************************************************************/
void E_(CloseFilter)( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t*)p_this;
filter_sys_t *p_sys = p_filter->p_sys;
if( p_sys->p_rsc ) img_resample_close( p_sys->p_rsc );
avpicture_free( &p_sys->tmp_pic );
free( p_sys );
}
/*****************************************************************************
* Do the processing here
*****************************************************************************/
static picture_t *Process( filter_t *p_filter, picture_t *p_pic )
{
filter_sys_t *p_sys = p_filter->p_sys;
AVPicture src_pic, dest_pic, inter_pic;
picture_t *p_pic_dst;
vlc_bool_t b_resize = p_sys->b_resize;
int i;
/* Request output picture */
p_pic_dst = p_filter->pf_vout_buffer_new( p_filter );
if( !p_pic_dst )
{
msg_Warn( p_filter, "can't get output picture" );
return NULL;
}
/* Prepare the AVPictures for the conversion */
for( i = 0; i < p_pic->i_planes; i++ )
{
src_pic.data[i] = p_pic->p[i].p_pixels;
src_pic.linesize[i] = p_pic->p[i].i_pitch;
}
for( i = 0; i < p_pic_dst->i_planes; i++ )
{
dest_pic.data[i] = p_pic_dst->p[i].p_pixels;
dest_pic.linesize[i] = p_pic_dst->p[i].i_pitch;
}
/* Special cases */
if( p_filter->fmt_in.video.i_chroma == VLC_FOURCC('Y','V','1','2') ||
p_filter->fmt_in.video.i_chroma == VLC_FOURCC('Y','V','U','9') )
{
/* Invert U and V */
src_pic.data[1] = p_pic->p[2].p_pixels;
src_pic.data[2] = p_pic->p[1].p_pixels;
}
if( p_filter->fmt_out.video.i_chroma == VLC_FOURCC('Y','V','1','2') ||
p_filter->fmt_out.video.i_chroma == VLC_FOURCC('Y','V','U','9') )
{
/* Invert U and V */
dest_pic.data[1] = p_pic_dst->p[2].p_pixels;
dest_pic.data[2] = p_pic_dst->p[1].p_pixels;
}
#if 0
if( p_sys->b_resize &&
p_filter->fmt_in.video.i_width * p_filter->fmt_in.video.i_height >
p_filter->fmt_out.video.i_width * p_filter->fmt_out.video.i_height )
{
img_resample( p_sys->p_rsc, &dest_pic, &p_sys->tmp_pic );
b_resize = 0;
}
#endif
if( p_sys->b_convert )
{
if( p_sys->b_resize ) inter_pic = p_sys->tmp_pic;
else inter_pic = dest_pic;
img_convert( &inter_pic, p_sys->i_dst_ffmpeg_chroma,
&src_pic, p_sys->i_src_ffmpeg_chroma,
p_filter->fmt_in.video.i_width,
p_filter->fmt_in.video.i_height );
src_pic = inter_pic;
}
if( p_sys->b_resize && p_sys->p_rsc )
{
img_resample( p_sys->p_rsc, &dest_pic, &src_pic );
}
p_pic_dst->date = p_pic->date;
p_pic_dst->b_force = p_pic->b_force;
p_pic_dst->i_nb_fields = p_pic->i_nb_fields;
p_pic_dst->b_progressive = p_pic->b_progressive;
p_pic_dst->b_top_field_first = p_pic->b_top_field_first;
p_pic->pf_release( p_pic );
return p_pic_dst;
}
modules/codec/libmpeg2.c
View file @ f2c55479
......@@ -430,7 +430,8 @@ static picture_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
p_sys->p_info->current_picture->nb_fields, i_pts, i_dts,
p_sys->i_current_rate );
if ( !(p_sys->b_slice_i
if( !p_dec->b_pace_control &&
!(p_sys->b_slice_i
&& ((p_sys->p_info->current_picture->flags
& PIC_MASK_CODING_TYPE) == P_CODING_TYPE))
&& !vout_SynchroChoose( p_sys->p_synchro,
......
modules/codec/speex.c
View file @ f2c55479
......@@ -92,7 +92,6 @@ static void ParseSpeexComments( decoder_t *, ogg_packet * );
static int OpenEncoder ( vlc_object_t * );
static void CloseEncoder ( vlc_object_t * );
static block_t *Headers ( encoder_t * );
static block_t *Encode ( encoder_t *, aout_buffer_t * );
/*****************************************************************************
......@@ -517,8 +516,6 @@ struct encoder_sys_t
/*
* Input properties
*/
int i_headers;
char *p_buffer;
char p_buffer_out[MAX_FRAME_BYTES];
......@@ -551,7 +548,10 @@ static int OpenEncoder( vlc_object_t *p_this )
encoder_t *p_enc = (encoder_t *)p_this;
encoder_sys_t *p_sys;
const SpeexMode *p_speex_mode = &speex_nb_mode;
int i_quality;
int i_quality, i;
char *pp_header[2];
int pi_header[2];
uint8_t *p_extra;
if( p_enc->fmt_out.i_codec != VLC_FOURCC('s','p','x',' ') &&
!p_enc->b_force )
......@@ -566,7 +566,6 @@ static int OpenEncoder( vlc_object_t *p_this )
return VLC_EGENERIC;
}
p_enc->p_sys = p_sys;
p_enc->pf_header = Headers;
p_enc->pf_encode_audio = Encode;
p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
p_enc->fmt_out.i_codec = VLC_FOURCC('s','p','x',' ');
......@@ -590,7 +589,6 @@ static int OpenEncoder( vlc_object_t *p_this )
p_sys->i_frames_in_packet = 0;
p_sys->i_samples_delay = 0;
p_sys->i_headers = 0;
p_sys->i_pts = 0;
speex_encoder_ctl( p_sys->p_state, SPEEX_GET_FRAME_SIZE,
......@@ -600,6 +598,22 @@ static int OpenEncoder( vlc_object_t *p_this )
sizeof(int16_t) * p_enc->fmt_in.audio.i_channels;
p_sys->p_buffer = malloc( p_sys->i_frame_size );
/* Create and store headers */
pp_header[0] = speex_header_to_packet( &p_sys->header, &pi_header[0] );
pp_header[1] = "ENCODER=VLC media player";
pi_header[1] = sizeof("ENCODER=VLC media player");
p_enc->fmt_out.i_extra = 1 + 3 * 2 + pi_header[0] + pi_header[1];
p_extra = p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
*(p_extra++) = 2; /* number of headers */
for( i = 0; i < 2; i++ )
{
*(p_extra++) = pi_header[i] >> 8;
*(p_extra++) = pi_header[i] & 0xFF;
memcpy( p_extra, pp_header[i], pi_header[i] );
p_extra += pi_header[i];
}
msg_Dbg( p_enc, "encoding: frame size:%d, channels:%d, samplerate:%d",
p_sys->i_frame_size, p_enc->fmt_in.audio.i_channels,
p_enc->fmt_in.audio.i_rate );
......@@ -607,42 +621,6 @@ static int OpenEncoder( vlc_object_t *p_this )
return VLC_SUCCESS;
}
/****************************************************************************
* Headers: spits out the headers
****************************************************************************
* This function spits out ogg packets.
****************************************************************************/
static block_t *Headers( encoder_t *p_enc )
{
encoder_sys_t *p_sys = p_enc->p_sys;
block_t *p_block, *p_chain = NULL;
/* Create speex headers */
if( !p_sys->i_headers )
{
char *p_buffer;
int i_buffer;
/* Main header */
p_buffer = speex_header_to_packet( &p_sys->header, &i_buffer );
p_block = block_New( p_enc, i_buffer );
memcpy( p_block->p_buffer, p_buffer, i_buffer );
p_block->i_dts = p_block->i_pts = p_block->i_length = 0;
block_ChainAppend( &p_chain, p_block );
/* Comment */
p_block = block_New( p_enc, sizeof("ENCODER=VLC media player") );
memcpy( p_block->p_buffer, "ENCODER=VLC media player",
p_block->i_buffer );
p_block->i_dts = p_block->i_pts = p_block->i_length = 0;
block_ChainAppend( &p_chain, p_block );
p_sys->i_headers = 2;
}
return p_chain;
}
/****************************************************************************
* Encode: the whole thing
****************************************************************************
......
modules/codec/theora.c
View file @ f2c55479
......@@ -76,7 +76,6 @@ static void theora_CopyPicture( decoder_t *, picture_t *, yuv_buffer * );
static int OpenEncoder( vlc_object_t *p_this );
static void CloseEncoder( vlc_object_t *p_this );
static block_t *Headers( encoder_t *p_enc );
static block_t *Encode( encoder_t *p_enc, picture_t *p_pict );
/*****************************************************************************
......@@ -460,8 +459,10 @@ static int OpenEncoder( vlc_object_t *p_this )
{
encoder_t *p_enc = (encoder_t *)p_this;
encoder_sys_t *p_sys = p_enc->p_sys;
ogg_packet header[3];
uint8_t *p_extra;
vlc_value_t val;
int i_quality;
int i_quality, i;
if( p_enc->fmt_out.i_codec != VLC_FOURCC('t','h','e','o') &&
!p_enc->b_force )
......@@ -486,7 +487,6 @@ static int OpenEncoder( vlc_object_t *p_this )
}
p_enc->p_sys = p_sys;
p_enc->pf_header = Headers;
p_enc->pf_encode_video = Encode;
p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','0');
p_enc->fmt_out.i_codec = VLC_FOURCC('t','h','e','o');
......@@ -548,54 +548,23 @@ static int OpenEncoder( vlc_object_t *p_this )
theora_info_clear( &p_sys->ti );
theora_comment_init( &p_sys->tc );
p_sys->b_headers = VLC_FALSE;
return VLC_SUCCESS;
}
/****************************************************************************
* Encode: the whole thing
****************************************************************************
* This function spits out ogg packets.
****************************************************************************/
static block_t *Headers( encoder_t *p_enc )
{
encoder_sys_t *p_sys = p_enc->p_sys;
block_t *p_chain = NULL;
/* Create theora headers */
if( !p_sys->b_headers )
{
ogg_packet oggpackets;
int i;
block_t *p_block;
/* Ogg packet to block */
/* Create and store headers */
theora_encode_header( &p_sys->td, &header[0] );
theora_encode_comment( &p_sys->tc, &header[1] );
theora_encode_tables( &p_sys->td, &header[2] );
p_enc->fmt_out.i_extra = 1 + 3 * 2 + header[0].bytes +
header[1].bytes + header[2].bytes;
p_extra = p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
*(p_extra++) = 3; /* number of headers */
for( i = 0; i < 3; i++ )
{
switch( i )
{
case 0:
theora_encode_header( &p_sys->td, &oggpackets );
break;
case 1:
theora_encode_comment( &p_sys->tc, &oggpackets );
break;
case 2:
theora_encode_tables( &p_sys->td, &oggpackets );
break;
}
p_block = block_New( p_enc, oggpackets.bytes );
memcpy( p_block->p_buffer, oggpackets.packet, oggpackets.bytes );
p_block->i_dts = p_block->i_pts = p_block->i_length = 0;
block_ChainAppend( &p_chain, p_block );
*(p_extra++) = header[i].bytes >> 8;
*(p_extra++) = header[i].bytes & 0xFF;
memcpy( p_extra, header[i].packet, header[i].bytes );
p_extra += header[i].bytes;
}
p_sys->b_headers = VLC_TRUE;
}
return p_chain;
return VLC_SUCCESS;
}
/****************************************************************************
......
modules/codec/toolame.c
View file @ f2c55479
......@@ -120,7 +120,6 @@ static int OpenEncoder( vlc_object_t *p_this )
}
p_enc->p_sys = p_sys;
p_enc->pf_header = NULL;
p_enc->pf_encode_audio = Encode;
p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
p_enc->fmt_out.i_codec = VLC_FOURCC('m','p','g','a');
......
modules/codec/vorbis.c
View file @ f2c55479
......@@ -117,7 +117,6 @@ static void Interleave ( float *, const float **, int, int );
#ifndef MODULE_NAME_IS_tremor
static int OpenEncoder ( vlc_object_t * );
static void CloseEncoder ( vlc_object_t * );
static block_t *Headers ( encoder_t * );
static block_t *Encode ( encoder_t *, aout_buffer_t * );
#endif
......@@ -549,15 +548,10 @@ static void CloseDecoder( vlc_object_t *p_this )
#if defined(HAVE_VORBIS_VORBISENC_H) && !defined(MODULE_NAME_IS_tremor)
/*****************************************************************************
* encoder_sys_t : theora encoder descriptor
* encoder_sys_t : vorbis encoder descriptor
*****************************************************************************/
struct encoder_sys_t
{
/*
* Input properties
*/
int i_headers;
/*
* Vorbis properties
*/
......@@ -586,8 +580,10 @@ static int OpenEncoder( vlc_object_t *p_this )
{
encoder_t *p_enc = (encoder_t *)p_this;
encoder_sys_t *p_sys;
int i_quality, i_min_bitrate, i_max_bitrate;
int i_quality, i_min_bitrate, i_max_bitrate, i;
ogg_packet header[3];
vlc_value_t val;
uint8_t *p_extra;
if( p_enc->fmt_out.i_codec != VLC_FOURCC('v','o','r','b') &&
!p_enc->b_force )
......@@ -603,7 +599,6 @@ static int OpenEncoder( vlc_object_t *p_this )
}
p_enc->p_sys = p_sys;
p_enc->pf_header = Headers;
p_enc->pf_encode_audio = Encode;
p_enc->fmt_in.i_codec = VLC_FOURCC('f','l','3','2');
p_enc->fmt_out.i_codec = VLC_FOURCC('v','o','r','b');
......@@ -671,54 +666,35 @@ static int OpenEncoder( vlc_object_t *p_this )
vorbis_encode_setup_init( &p_sys->vi );
/* add a comment */
/* Add a comment */
vorbis_comment_init( &p_sys->vc);
vorbis_comment_add_tag( &p_sys->vc, "ENCODER", "VLC media player");
/* set up the analysis state and auxiliary encoding storage */
/* Set up the analysis state and auxiliary encoding storage */
vorbis_analysis_init( &p_sys->vd, &p_sys->vi );
vorbis_block_init( &p_sys->vd, &p_sys->vb );
p_sys->i_channels = p_enc->fmt_in.audio.i_channels;
p_sys->i_last_block_size = 0;
p_sys->i_samples_delay = 0;
p_sys->i_headers = 0;
p_sys->i_pts = 0;
return VLC_SUCCESS;
}
/****************************************************************************
* Encode: the whole thing
****************************************************************************
* This function spits out ogg packets.
****************************************************************************/
static block_t *Headers( encoder_t *p_enc )
{
encoder_sys_t *p_sys = p_enc->p_sys;
block_t *p_block, *p_chain = NULL;
/* Create theora headers */
if( !p_sys->i_headers )
{
ogg_packet header[3];
int i;
/* Create and store headers */
vorbis_analysis_headerout( &p_sys->vd, &p_sys->vc,
&header[0], &header[1], &header[2]);
p_enc->fmt_out.i_extra = 1 + 3 * 2 + header[0].bytes +
header[1].bytes + header[2].bytes;
p_extra = p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
*(p_extra++) = 3; /* number of headers */
for( i = 0; i < 3; i++ )
{
p_block = block_New( p_enc, header[i].bytes );
memcpy( p_block->p_buffer, header[i].packet, header[i].bytes );
p_block->i_dts = p_block->i_pts = p_block->i_length = 0;
block_ChainAppend( &p_chain, p_block );
}
p_sys->i_headers = 3;
*(p_extra++) = header[i].bytes >> 8;
*(p_extra++) = header[i].bytes & 0xFF;
memcpy( p_extra, header[i].packet, header[i].bytes );
p_extra += header[i].bytes;
}
return p_chain;
p_sys->i_channels = p_enc->fmt_in.audio.i_channels;
p_sys->i_last_block_size = 0;
p_sys->i_samples_delay = 0;
p_sys->i_pts = 0;
return VLC_SUCCESS;
}
/****************************************************************************
......@@ -791,7 +767,7 @@ static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
}
/*****************************************************************************
* CloseEncoder: theora encoder destruction
* CloseEncoder: vorbis encoder destruction
*****************************************************************************/
static void CloseEncoder( vlc_object_t *p_this )
{
......
modules/stream_out/transcode.c
View file @ f2c55479
......@@ -214,15 +214,21 @@ static sout_stream_id_t *Add ( sout_stream_t *, es_format_t * );
static int Del ( sout_stream_t *, sout_stream_id_t * );
static int Send( sout_stream_t *, sout_stream_id_t *, block_t* );
static int transcode_audio_ffmpeg_new ( sout_stream_t *, sout_stream_id_t * );
static void transcode_audio_ffmpeg_close ( sout_stream_t *, sout_stream_id_t * );
static int transcode_audio_ffmpeg_process( sout_stream_t *, sout_stream_id_t *, block_t *, block_t ** );
static int transcode_audio_new ( sout_stream_t *, sout_stream_id_t * );
static void transcode_audio_close ( sout_stream_t *, sout_stream_id_t * );
static int transcode_audio_process( sout_stream_t *, sout_stream_id_t *,
block_t *, block_t ** );
static int transcode_video_ffmpeg_new ( sout_stream_t *, sout_stream_id_t * );
static void transcode_video_ffmpeg_close ( sout_stream_t *, sout_stream_id_t * );
static int transcode_video_ffmpeg_process( sout_stream_t *, sout_stream_id_t *, block_t *, block_t ** );
static int transcode_video_new ( sout_stream_t *, sout_stream_id_t * );
static void transcode_video_close ( sout_stream_t *, sout_stream_id_t * );
static int transcode_video_encoder_open( sout_stream_t *, sout_stream_id_t *);
static int transcode_video_process( sout_stream_t *, sout_stream_id_t *,
block_t *, block_t ** );
static int transcode_video_ffmpeg_getframebuf( struct AVCodecContext *, AVFrame *);
static picture_t *video_new_buffer( decoder_t * );
static void video_del_buffer( decoder_t *, picture_t * );
static void video_link_picture( decoder_t *, picture_t * );
static void video_unlink_picture( decoder_t *, picture_t * );
static int transcode_spu_new ( sout_stream_t *, sout_stream_id_t * );
static void transcode_spu_close ( sout_stream_t *, sout_stream_id_t * );
......@@ -251,9 +257,9 @@ struct sout_stream_sys_t
{
VLC_COMMON_MEMBERS
sout_stream_t * p_out;
sout_stream_id_t * id_video;
block_t * p_buffers;
sout_stream_t *p_out;
sout_stream_id_t *id_video;
block_t *p_buffers;
vlc_mutex_t lock_out;
vlc_cond_t cond;
picture_t * pp_pics[PICTURE_RING_SIZE];
......@@ -284,12 +290,6 @@ struct sout_stream_sys_t
int i_crop_right;
int i_crop_left;
mtime_t i_input_dts;
mtime_t i_input_pts;
vlc_bool_t b_input_has_b_frames;
mtime_t i_output_pts;
/* SPU */
vlc_fourcc_t i_scodec; /* codec spu (0 if not transcode) */
char *psz_senc;
......@@ -325,8 +325,6 @@ static int Open( vlc_object_t *p_this )
return VLC_EGENERIC;
}
p_sys->b_input_has_b_frames = VLC_FALSE;
p_sys->i_output_pts = 0;
p_sys->i_master_drift = 0;
sout_CfgParse( p_stream, SOUT_CFG_PREFIX, ppsz_sout_options,
......@@ -553,8 +551,7 @@ static void Close( vlc_object_t * p_this )
struct sout_stream_id_t
{
vlc_fourcc_t b_transcode;
es_format_t f_src; /* only if transcoding */
es_format_t f_dst; /* " " " */
unsigned int i_inter_pixfmt; /* intermediary format when transcoding */
/* id of the out stream */
......@@ -563,9 +560,12 @@ struct sout_stream_id_t
/* Decoder */
decoder_t *p_decoder;
/* Filters */
filter_t *pp_filter[10];
int i_filter;
/* Encoder */
encoder_t *p_encoder;
vlc_fourcc_t b_enc_inited;
/* ffmpeg part */
AVCodec *ff_dec;
......@@ -604,15 +604,37 @@ static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
id->p_decoder = NULL;
id->p_encoder = NULL;
/* Get source format */
id->f_src = *p_fmt;
/* Create decoder object */
id->p_decoder = vlc_object_create( p_stream, VLC_OBJECT_DECODER );
if( !id->p_decoder )
{
msg_Err( p_stream, "out of memory" );
goto error;
}
vlc_object_attach( id->p_decoder, p_stream );
id->p_decoder->p_module = NULL;
id->p_decoder->fmt_in = *p_fmt;
id->p_decoder->fmt_out = *p_fmt;
id->p_decoder->fmt_out.i_extra = 0;
id->p_decoder->fmt_out.p_extra = 0;
id->p_decoder->b_pace_control = VLC_TRUE;
/* Create encoder object */
id->p_encoder = vlc_object_create( p_stream, VLC_OBJECT_ENCODER );
if( !id->p_encoder )
{
msg_Err( p_stream, "out of memory" );
goto error;
}
vlc_object_attach( id->p_encoder, p_stream );
id->p_encoder->p_module = NULL;
/* Create destination format */
es_format_Init( &id->f_dst, p_fmt->i_cat, 0 );
id->f_dst.i_id = id->f_src.i_id;
id->f_dst.i_group = id->f_src.i_group;
if( id->f_src.psz_language )
id->f_dst.psz_language = strdup( id->f_src.psz_language );
es_format_Init( &id->p_encoder->fmt_out, p_fmt->i_cat, 0 );
id->p_encoder->fmt_out.i_id = p_fmt->i_id;
id->p_encoder->fmt_out.i_group = p_fmt->i_group;
if( p_fmt->psz_language )
id->p_encoder->fmt_out.psz_language = strdup( p_fmt->psz_language );
if( p_fmt->i_cat == AUDIO_ES && (p_sys->i_acodec || p_sys->psz_aenc) )
{
......@@ -621,31 +643,27 @@ static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
(char*)&p_fmt->i_codec, (char*)&p_sys->i_acodec );
/* Complete destination format */
id->f_dst.i_codec = p_sys->i_acodec;
id->f_dst.audio.i_rate = p_sys->i_sample_rate > 0 ?
p_sys->i_sample_rate : id->f_src.audio.i_rate;
id->f_dst.audio.i_channels = p_sys->i_channels > 0 ?
p_sys->i_channels : id->f_src.audio.i_channels;
id->f_dst.i_bitrate = p_sys->i_abitrate;
id->f_dst.audio.i_bitspersample = id->f_src.audio.i_bitspersample;
/* build decoder -> filter -> encoder */
if( transcode_audio_ffmpeg_new( p_stream, id ) )
id->p_encoder->fmt_out.i_codec = p_sys->i_acodec;
id->p_encoder->fmt_out.audio.i_rate = p_sys->i_sample_rate > 0 ?
p_sys->i_sample_rate : (int)p_fmt->audio.i_rate;
id->p_encoder->fmt_out.audio.i_channels = p_sys->i_channels > 0 ?
p_sys->i_channels : p_fmt->audio.i_channels;
id->p_encoder->fmt_out.i_bitrate = p_sys->i_abitrate;
id->p_encoder->fmt_out.audio.i_bitspersample =
p_fmt->audio.i_bitspersample;
/* Build decoder -> filter -> encoder chain */
if( transcode_audio_new( p_stream, id ) )
{
msg_Err( p_stream, "cannot create audio chain" );
free( id );
return NULL;
goto error;
}
/* open output stream */
id->id = p_sys->p_out->pf_add( p_sys->p_out, &id->f_dst );
/* Open output stream */
id->id = p_sys->p_out->pf_add( p_sys->p_out, &id->p_encoder->fmt_out );
id->b_transcode = VLC_TRUE;
if( id->id == NULL )
{
free( id );
return NULL;
}
if( !id->id ) goto error;
date_Init( &id->interpolated_pts, p_fmt->audio.i_rate, 1 );
}
......@@ -657,34 +675,26 @@ static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
(char*)&p_fmt->i_codec, (char*)&p_sys->i_vcodec );
/* Complete destination format */
id->f_dst.i_codec = p_sys->i_vcodec;
id->f_dst.video.i_width = p_sys->i_width;
id->f_dst.video.i_height = p_sys->i_height;
id->f_dst.i_bitrate = p_sys->i_vbitrate;
id->p_encoder->fmt_out.i_codec = p_sys->i_vcodec;
id->p_encoder->fmt_out.video.i_width = p_sys->i_width;
id->p_encoder->fmt_out.video.i_height = p_sys->i_height;
id->p_encoder->fmt_out.i_bitrate = p_sys->i_vbitrate;
/* build decoder -> filter -> encoder */
if( transcode_video_ffmpeg_new( p_stream, id ) )
/* Build decoder -> filter -> encoder chain */
if( transcode_video_new( p_stream, id ) )
{
msg_Err( p_stream, "cannot create video chain" );
free( id );
return NULL;
goto error;
}
#if 0
/* open output stream */
id->id = p_sys->p_out->pf_add( p_sys->p_out, &id->f_dst );
#endif
/* Stream will be added later on because we don't know
* all the characteristics of the decoded stream yet */
id->b_transcode = VLC_TRUE;
if( id->f_dst.video.i_frame_rate && id->f_dst.video.i_frame_rate_base )
{
date_Init( &id->interpolated_pts, id->f_dst.video.i_frame_rate,
id->f_dst.video.i_frame_rate_base );
}
else if( p_sys->b_audio_sync )
if( p_sys->f_fps > 0 )
{
msg_Warn( p_stream, "no video frame rate available, disabling "
"audio sync" );
p_sys->b_audio_sync = VLC_FALSE;
id->p_encoder->fmt_out.video.i_frame_rate = p_sys->f_fps * 1000;
id->p_encoder->fmt_out.video.i_frame_rate_base = 1000;
}
}
else if( p_fmt->i_cat == SPU_ES && (p_sys->i_scodec || p_sys->psz_senc) )
......@@ -694,25 +704,20 @@ static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
(char*)&p_sys->i_scodec );
/* Complete destination format */
id->f_dst.i_codec = p_sys->i_scodec;
id->p_encoder->fmt_out.i_codec = p_sys->i_scodec;
/* build decoder -> filter -> encoder */
if( transcode_spu_new( p_stream, id ) )
{
msg_Err( p_stream, "cannot create subtitles chain" );
free( id );
return NULL;
goto error;
}
/* open output stream */
id->id = p_sys->p_out->pf_add( p_sys->p_out, &id->f_dst );
id->id = p_sys->p_out->pf_add( p_sys->p_out, &id->p_encoder->fmt_out );
id->b_transcode = VLC_TRUE;
if( id->id == NULL )
{
free( id );
return NULL;
}
if( !id->id ) goto error;
}
else if( p_fmt->i_cat == SPU_ES && p_sys->b_soverlay )
{
......@@ -721,12 +726,11 @@ static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
id->b_transcode = VLC_TRUE;
/* build decoder -> filter -> encoder */
/* Build decoder -> filter -> overlaying chain */
if( transcode_spu_new( p_stream, id ) )
{
msg_Err( p_stream, "cannot create subtitles chain" );
free( id );
return NULL;
goto error;
}
}
else
......@@ -736,14 +740,26 @@ static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
id->id = p_sys->p_out->pf_add( p_sys->p_out, p_fmt );
id->b_transcode = VLC_FALSE;
if( id->id == NULL )
if( !id->id ) goto error;
}
return id;
error:
if( id->p_decoder )
{
free( id );
return NULL;
vlc_object_detach( id->p_decoder );
vlc_object_destroy( id->p_decoder );
}
if( id->p_encoder )
{
vlc_object_detach( id->p_encoder );
vlc_object_destroy( id->p_encoder );
}
return id;
free( id );
return NULL;
}
static int Del( sout_stream_t *p_stream, sout_stream_id_t *id )
......@@ -752,21 +768,34 @@ static int Del( sout_stream_t *p_stream, sout_stream_id_t *id )
if( id->b_transcode )
{
if( id->f_src.i_cat == AUDIO_ES )
switch( id->p_decoder->fmt_in.i_cat )
{
transcode_audio_ffmpeg_close( p_stream, id );
case AUDIO_ES:
transcode_audio_close( p_stream, id );
break;
case VIDEO_ES:
transcode_video_close( p_stream, id );
break;
case SPU_ES:
transcode_spu_close( p_stream, id );
break;
}
else if( id->f_src.i_cat == VIDEO_ES )
{
transcode_video_ffmpeg_close( p_stream, id );
}
else if( id->f_src.i_cat == SPU_ES )
if( id->id ) p_sys->p_out->pf_del( p_sys->p_out, id->id );
if( id->p_decoder )
{
transcode_spu_close( p_stream, id );
vlc_object_detach( id->p_decoder );
vlc_object_destroy( id->p_decoder );
}
if( id->p_encoder )
{
vlc_object_detach( id->p_encoder );
vlc_object_destroy( id->p_encoder );
}
if( id->id ) p_sys->p_out->pf_del( p_sys->p_out, id->id );
free( id );
return VLC_SUCCESS;
......@@ -776,64 +805,48 @@ static int Send( sout_stream_t *p_stream, sout_stream_id_t *id,
block_t *p_buffer )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
block_t *p_out;
if( id->b_transcode )
if( !id->b_transcode && id->id )
{
block_t *p_buffer_out;
/* Be sure to have padding */
p_buffer = block_Realloc( p_buffer, 0, p_buffer->i_buffer + FF_INPUT_BUFFER_PADDING_SIZE );
if( p_buffer == NULL )
return p_sys->p_out->pf_send( p_sys->p_out, id->id, p_buffer );
}
else if( !id->b_transcode )
{
block_Release( p_buffer );
return VLC_EGENERIC;
}
p_buffer->i_buffer -= FF_INPUT_BUFFER_PADDING_SIZE;
memset( &p_buffer->p_buffer[p_buffer->i_buffer], 0, FF_INPUT_BUFFER_PADDING_SIZE );
if( id->f_src.i_cat == AUDIO_ES )
switch( id->p_decoder->fmt_in.i_cat )
{
transcode_audio_ffmpeg_process( p_stream, id, p_buffer,
&p_buffer_out );
case AUDIO_ES:
transcode_audio_process( p_stream, id, p_buffer, &p_out );
block_Release( p_buffer );
}
else if( id->f_src.i_cat == VIDEO_ES )
{
if( transcode_video_ffmpeg_process( p_stream, id, p_buffer,
&p_buffer_out ) != VLC_SUCCESS )
break;
case VIDEO_ES:
if( transcode_video_process( p_stream, id, p_buffer, &p_out )
!= VLC_SUCCESS )
{
block_Release( p_buffer );
return VLC_EGENERIC;
}
block_Release( p_buffer );
}
else if( id->f_src.i_cat == SPU_ES )
{
if( transcode_spu_process( p_stream, id, p_buffer,
&p_buffer_out ) != VLC_SUCCESS )
break;
case SPU_ES:
if( transcode_spu_process( p_stream, id, p_buffer, &p_out ) !=
VLC_SUCCESS )
{
return VLC_EGENERIC;
}
}
else
{
break;
default:
block_Release( p_buffer );
break;
}
if( p_buffer_out )
{
return p_sys->p_out->pf_send( p_sys->p_out, id->id, p_buffer_out );
}
if( p_out ) return p_sys->p_out->pf_send( p_sys->p_out, id->id, p_out );
return VLC_SUCCESS;
}
else if( id->id != NULL )
{
return p_sys->p_out->pf_send( p_sys->p_out, id->id, p_buffer );
}
else
{
block_Release( p_buffer );
return VLC_EGENERIC;
}
}
/****************************************************************************
......@@ -843,6 +856,7 @@ static struct
{
vlc_fourcc_t i_fcc;
int i_ff_codec;
} fourcc_to_ff_code[] =
{
/* audio */
......@@ -856,45 +870,6 @@ static struct
{ VLC_FOURCC( 'v', 'o', 'r', 'b' ), CODEC_ID_VORBIS },
{ VLC_FOURCC( 'a', 'l', 'a', 'w' ), CODEC_ID_PCM_ALAW },
/* video */
{ VLC_FOURCC( 'm', 'p', 'g', 'v' ), CODEC_ID_MPEG1VIDEO },
{ VLC_FOURCC( 'm', 'p', '1', 'v' ), CODEC_ID_MPEG1VIDEO },
#if LIBAVCODEC_BUILD >= 4676
{ VLC_FOURCC( 'm', 'p', '2', 'v' ), CODEC_ID_MPEG2VIDEO },
#endif
{ VLC_FOURCC( 'm', 'p', '4', 'v'), CODEC_ID_MPEG4 },
{ VLC_FOURCC( 'D', 'I', 'V', '1' ), CODEC_ID_MSMPEG4V1 },
{ VLC_FOURCC( 'D', 'I', 'V', '2' ), CODEC_ID_MSMPEG4V2 },
{ VLC_FOURCC( 'D', 'I', 'V', '3' ), CODEC_ID_MSMPEG4V3 },
{ VLC_FOURCC( 'H', '2', '6', '3' ), CODEC_ID_H263 },
{ VLC_FOURCC( 'I', '2', '6', '3' ), CODEC_ID_H263I },
{ VLC_FOURCC( 'h', 'u', 'f', 'f' ), CODEC_ID_HUFFYUV },
{ VLC_FOURCC( 'W', 'M', 'V', '1' ), CODEC_ID_WMV1 },
{ VLC_FOURCC( 'W', 'M', 'V', '2' ), CODEC_ID_WMV2 },
{ VLC_FOURCC( 'M', 'J', 'P', 'G' ), CODEC_ID_MJPEG },
{ VLC_FOURCC( 'm', 'j', 'p', 'b' ), CODEC_ID_MJPEGB },
{ VLC_FOURCC( 'd', 'v', 's', 'l' ), CODEC_ID_DVVIDEO },
{ VLC_FOURCC( 'S', 'V', 'Q', '1' ), CODEC_ID_SVQ1 },
#if LIBAVCODEC_BUILD >= 4666
{ VLC_FOURCC( 'S', 'V', 'Q', '3' ), CODEC_ID_SVQ3 },
{ VLC_FOURCC( 'h', '2', '6', '4' ), CODEC_ID_H264 },
#endif
#if LIBAVCODEC_BUILD >= 4719
{ VLC_FOURCC( 'S', 'N', 'O', 'W' ), CODEC_ID_SNOW },
#endif
/* raw video code, only used for 'encoding' */
{ VLC_FOURCC( 'I', '4', '2', '0' ), CODEC_ID_RAWVIDEO },
{ VLC_FOURCC( 'I', '4', '2', '2' ), CODEC_ID_RAWVIDEO },
{ VLC_FOURCC( 'I', '4', '4', '4' ), CODEC_ID_RAWVIDEO },
{ VLC_FOURCC( 'R', 'V', '1', '5' ), CODEC_ID_RAWVIDEO },
{ VLC_FOURCC( 'R', 'V', '1', '6' ), CODEC_ID_RAWVIDEO },
{ VLC_FOURCC( 'R', 'V', '2', '4' ), CODEC_ID_RAWVIDEO },
{ VLC_FOURCC( 'R', 'V', '3', '2' ), CODEC_ID_RAWVIDEO },
{ VLC_FOURCC( 'Y', 'U', 'Y', '2' ), CODEC_ID_RAWVIDEO },
{ VLC_FOURCC( 'Y', 'V', '1', '2' ), CODEC_ID_RAWVIDEO },
{ VLC_FOURCC( 'I', 'Y', 'U', 'V' ), CODEC_ID_RAWVIDEO },
{ VLC_FOURCC( 0, 0, 0, 0 ), 0 }
};
......@@ -913,90 +888,28 @@ static inline int get_ff_codec( vlc_fourcc_t i_fcc )
return 0;
}
static inline int get_ff_chroma( vlc_fourcc_t i_chroma )
{
switch( i_chroma )
{
case VLC_FOURCC( 'Y', 'V', '1', '2' ):
case VLC_FOURCC( 'I', 'Y', 'U', 'V' ):
case VLC_FOURCC( 'I', '4', '2', '0' ):
return PIX_FMT_YUV420P;
case VLC_FOURCC( 'I', '4', '2', '2' ):
return PIX_FMT_YUV422P;
case VLC_FOURCC( 'I', '4', '4', '4' ):
return PIX_FMT_YUV444P;
case VLC_FOURCC( 'R', 'V', '1', '5' ):
return PIX_FMT_RGB555;
case VLC_FOURCC( 'R', 'V', '1', '6' ):
return PIX_FMT_RGB565;
case VLC_FOURCC( 'R', 'V', '2', '4' ):
return PIX_FMT_BGR24;
case VLC_FOURCC( 'R', 'V', '3', '2' ):
return PIX_FMT_RGBA32;
case VLC_FOURCC( 'G', 'R', 'E', 'Y' ):
return PIX_FMT_GRAY8;
case VLC_FOURCC( 'Y', 'U', 'Y', '2' ):
return PIX_FMT_YUV422;
default:
return 0;
}
}
static inline vlc_fourcc_t get_vlc_chroma( int i_pix_fmt )
{
switch( i_pix_fmt )
{
case PIX_FMT_YUV420P:
return VLC_FOURCC('I','4','2','0');
case PIX_FMT_YUV422P:
return VLC_FOURCC('I','4','2','2');
case PIX_FMT_YUV444P:
return VLC_FOURCC('I','4','4','4');
case PIX_FMT_YUV422:
return VLC_FOURCC('Y','U','Y','2');
case PIX_FMT_RGB555:
return VLC_FOURCC('R','V','1','5');
case PIX_FMT_RGB565:
return VLC_FOURCC('R','V','1','6');
case PIX_FMT_RGB24:
return VLC_FOURCC('R','V','2','4');
case PIX_FMT_RGBA32:
return VLC_FOURCC('R','V','3','2');
case PIX_FMT_GRAY8:
return VLC_FOURCC('G','R','E','Y');
case PIX_FMT_YUV410P:
case PIX_FMT_YUV411P:
case PIX_FMT_BGR24:
default:
return 0;
}
}
static int transcode_audio_ffmpeg_new( sout_stream_t *p_stream,
static int transcode_audio_new( sout_stream_t *p_stream,
sout_stream_id_t *id )
{
int i_ff_codec;
if( id->f_src.i_codec == VLC_FOURCC('s','1','6','l') ||
id->f_src.i_codec == VLC_FOURCC('s','1','6','b') ||
id->f_src.i_codec == VLC_FOURCC('s','8',' ',' ') ||
id->f_src.i_codec == VLC_FOURCC('u','8',' ',' ') )
if( id->p_decoder->fmt_in.i_codec == VLC_FOURCC('s','1','6','l') ||
id->p_decoder->fmt_in.i_codec == VLC_FOURCC('s','1','6','b') ||
id->p_decoder->fmt_in.i_codec == VLC_FOURCC('s','8',' ',' ') ||
id->p_decoder->fmt_in.i_codec == VLC_FOURCC('u','8',' ',' ') )
{
id->ff_dec = NULL;
id->ff_dec_c = avcodec_alloc_context();
id->ff_dec_c->sample_rate = id->f_src.audio.i_rate;
id->ff_dec_c->channels = id->f_src.audio.i_channels;
id->ff_dec_c->block_align = id->f_src.audio.i_blockalign;
id->ff_dec_c->bit_rate = id->f_src.i_bitrate;
id->ff_dec_c->sample_rate = id->p_decoder->fmt_in.audio.i_rate;
id->ff_dec_c->channels = id->p_decoder->fmt_in.audio.i_channels;
id->ff_dec_c->block_align = id->p_decoder->fmt_in.audio.i_blockalign;
id->ff_dec_c->bit_rate = id->p_decoder->fmt_in.i_bitrate;
}
else
{
/* find decoder */
i_ff_codec = get_ff_codec( id->f_src.i_codec );
i_ff_codec = get_ff_codec( id->p_decoder->fmt_in.i_codec );
if( i_ff_codec == 0 )
{
msg_Err( p_stream, "cannot find decoder id" );
......@@ -1011,13 +924,13 @@ static int transcode_audio_ffmpeg_new( sout_stream_t *p_stream,
}
id->ff_dec_c = avcodec_alloc_context();
id->ff_dec_c->sample_rate = id->f_src.audio.i_rate;
id->ff_dec_c->channels = id->f_src.audio.i_channels;
id->ff_dec_c->block_align = id->f_src.audio.i_blockalign;
id->ff_dec_c->bit_rate = id->f_src.i_bitrate;
id->ff_dec_c->sample_rate = id->p_decoder->fmt_in.audio.i_rate;
id->ff_dec_c->channels = id->p_decoder->fmt_in.audio.i_channels;
id->ff_dec_c->block_align = id->p_decoder->fmt_in.audio.i_blockalign;
id->ff_dec_c->bit_rate = id->p_decoder->fmt_in.i_bitrate;
id->ff_dec_c->extradata_size = id->f_src.i_extra;
id->ff_dec_c->extradata = id->f_src.p_extra;
id->ff_dec_c->extradata_size = id->p_decoder->fmt_in.i_extra;
id->ff_dec_c->extradata = id->p_decoder->fmt_in.p_extra;
if( avcodec_open( id->ff_dec_c, id->ff_dec ) )
{
msg_Err( p_stream, "cannot open decoder" );
......@@ -1031,29 +944,23 @@ static int transcode_audio_ffmpeg_new( sout_stream_t *p_stream,
id->p_buffer = malloc( id->i_buffer );
/* Sanity check for audio channels */
id->f_dst.audio.i_channels =
__MIN( id->f_dst.audio.i_channels, id->f_src.audio.i_channels );
/* find encoder */
id->p_encoder = vlc_object_create( p_stream, VLC_OBJECT_ENCODER );
id->p_encoder->fmt_out.audio.i_channels =
__MIN( id->p_encoder->fmt_out.audio.i_channels,
id->p_decoder->fmt_in.audio.i_channels );
/* Initialization of encoder format structures */
es_format_Init( &id->p_encoder->fmt_in, AUDIO_ES, AOUT_FMT_S16_NE );
id->p_encoder->fmt_in.audio.i_format = AOUT_FMT_S16_NE;
id->p_encoder->fmt_in.audio.i_rate = id->f_dst.audio.i_rate;
id->p_encoder->fmt_in.audio.i_rate = id->p_encoder->fmt_out.audio.i_rate;
id->p_encoder->fmt_in.audio.i_physical_channels =
id->p_encoder->fmt_in.audio.i_original_channels =
pi_channels_maps[id->f_dst.audio.i_channels];
id->p_encoder->fmt_in.audio.i_channels = id->f_dst.audio.i_channels;
pi_channels_maps[id->p_encoder->fmt_out.audio.i_channels];
id->p_encoder->fmt_in.audio.i_channels =
id->p_encoder->fmt_out.audio.i_channels;
id->p_encoder->fmt_in.audio.i_bitspersample = 16;
id->p_encoder->fmt_out = id->f_dst;
id->p_encoder->p_cfg = p_stream->p_sys->p_audio_cfg;
/* Attach object to parent so object variables inheritance works */
vlc_object_attach( id->p_encoder, p_stream );
id->p_encoder->p_module =
module_Need( id->p_encoder, "encoder",
p_stream->p_sys->psz_aenc, VLC_TRUE );
......@@ -1066,20 +973,14 @@ static int transcode_audio_ffmpeg_new( sout_stream_t *p_stream,
return VLC_EGENERIC;
}
id->b_enc_inited = VLC_FALSE;
id->f_dst = id->p_encoder->fmt_out;
/* Hack for mp3 transcoding support */
if( id->f_dst.i_codec == VLC_FOURCC( 'm','p','3',' ' ) )
{
id->f_dst.i_codec = VLC_FOURCC( 'm','p','g','a' );
}
/* FIXME: Hack for mp3 transcoding support */
if( id->p_encoder->fmt_out.i_codec == VLC_FOURCC( 'm','p','3',' ' ) )
id->p_encoder->fmt_out.i_codec = VLC_FOURCC( 'm','p','g','a' );
return VLC_SUCCESS;
}
static void transcode_audio_ffmpeg_close( sout_stream_t *p_stream,
static void transcode_audio_close( sout_stream_t *p_stream,
sout_stream_id_t *id )
{
if( id->ff_dec ) avcodec_close( id->ff_dec_c );
......@@ -1093,10 +994,9 @@ static void transcode_audio_ffmpeg_close( sout_stream_t *p_stream,
free( id->p_buffer );
}
static int transcode_audio_ffmpeg_process( sout_stream_t *p_stream,
static int transcode_audio_process( sout_stream_t *p_stream,
sout_stream_id_t *id,
block_t *in,
block_t **out )
block_t *in, block_t **out )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
aout_buffer_t aout_buf;
......@@ -1141,15 +1041,16 @@ static int transcode_audio_ffmpeg_process( sout_stream_t *p_stream,
else
{
int16_t *sout = (int16_t*)id->p_buffer;
vlc_fourcc_t i_codec = id->p_decoder->fmt_in.i_codec;
if( id->f_src.i_codec == VLC_FOURCC( 's', '8', ' ', ' ' ) ||
id->f_src.i_codec == VLC_FOURCC( 'u', '8', ' ', ' ' ) )
if( i_codec == VLC_FOURCC('s','8',' ',' ') ||
i_codec == VLC_FOURCC('u','8',' ',' ') )
{
int8_t *sin = (int8_t*)p_buffer;
int i_used = __MIN( id->i_buffer/2, i_buffer );
int i_samples = i_used;
if( id->f_src.i_codec == VLC_FOURCC( 's', '8', ' ', ' ' ) )
if( i_codec == VLC_FOURCC('s','8',' ',' ') )
while( i_samples > 0 )
{
*sout++ = ( *sin++ ) << 8;
......@@ -1166,8 +1067,8 @@ static int transcode_audio_ffmpeg_process( sout_stream_t *p_stream,
p_buffer += i_used;
id->i_buffer_pos = i_used * 2;
}
else if( id->f_src.i_codec == VLC_FOURCC( 's', '1', '6', 'l' ) ||
id->f_src.i_codec == VLC_FOURCC( 's', '1', '6', 'b' ) )
else if( i_codec == VLC_FOURCC('s','1','6','l') ||
i_codec == VLC_FOURCC('s','1','6','b') )
{
int16_t *sin = (int16_t*)p_buffer;
int i_used = __MIN( id->i_buffer, i_buffer );
......@@ -1177,9 +1078,9 @@ static int transcode_audio_ffmpeg_process( sout_stream_t *p_stream,
memcpy( sout, sin, i_used );
#ifdef WORDS_BIGENDIAN
if( id->f_src.i_codec == VLC_FOURCC( 's', '1', '6', 'l' ) )
if( i_codec == VLC_FOURCC('s','1','6','l') )
#else
if( id->f_src.i_codec == VLC_FOURCC( 's', '1', '6', 'b' ) )
if( i_codec == VLC_FOURCC('s','1','6','b') )
#endif
{
uint8_t *dat = (uint8_t*)sout;
......@@ -1205,26 +1106,10 @@ static int transcode_audio_ffmpeg_process( sout_stream_t *p_stream,
if( id->i_buffer_pos == 0 ) continue;
/* Encode as much data as possible */
if( !id->b_enc_inited && id->p_encoder->pf_header )
{
block_t *p_block_tmp;
p_block = id->p_encoder->pf_header( id->p_encoder );
p_block_tmp = p_block;
while( p_block_tmp )
{
p_block_tmp->i_dts = p_block_tmp->i_pts = in->i_dts;
p_block_tmp = p_block_tmp->p_next;
}
block_ChainAppend( out, p_block );
id->b_enc_inited = VLC_TRUE;
}
aout_buf.p_buffer = id->p_buffer;
aout_buf.i_nb_bytes = id->i_buffer_pos;
aout_buf.i_nb_samples = id->i_buffer_pos/2/id->f_src.audio.i_channels;
aout_buf.i_nb_samples = id->i_buffer_pos / 2 /
id->p_decoder->fmt_in.audio.i_channels;
aout_buf.start_date = id->i_dts;
aout_buf.end_date = id->i_dts;
......@@ -1236,13 +1121,14 @@ static int transcode_audio_ffmpeg_process( sout_stream_t *p_stream,
}
id->i_dts += ( I64C(1000000) * id->i_buffer_pos / 2 /
id->f_src.audio.i_channels / id->f_src.audio.i_rate );
id->p_decoder->fmt_in.audio.i_channels /
id->p_decoder->fmt_in.audio.i_rate );
if( id->p_encoder->fmt_in.audio.i_channels == 1 &&
id->f_src.audio.i_channels > 1 )
id->p_decoder->fmt_in.audio.i_channels > 1 )
{
int16_t *p_sample = (int16_t *)aout_buf.p_buffer;
int i_src_c = id->f_src.audio.i_channels;
int i_src_c = id->p_decoder->fmt_in.audio.i_channels;
unsigned int i;
for( i = 0; i < aout_buf.i_nb_samples; i++ )
......@@ -1258,19 +1144,19 @@ static int transcode_audio_ffmpeg_process( sout_stream_t *p_stream,
aout_buf.i_nb_bytes = i * 2;
}
else if( id->p_encoder->fmt_in.audio.i_channels == 2 &&
id->f_src.audio.i_channels > 2 )
id->p_decoder->fmt_in.audio.i_channels > 2 )
{
int i_src_c = id->f_src.audio.i_channels;
int i_src_c = id->p_decoder->fmt_in.audio.i_channels;
unsigned int i;
static const float mixf_l[4][6] = /* [i_src_c - 3][channel index] */
static const float mixf_l[4][6] =/* [i_src_c - 3][channel index] */
{
{ 0.00, 1.00, 0.00, 0.00, 0.00, 0.00 }, /* 3 channels */
{ 0.00, 0.50, 0.50, 0.00, 0.00, 0.00 }, /* 4 channels */
{ 0.00, 0.50, 0.00, 0.50, 0.00, 0.00 }, /* 5 channels */
{ 0.00, 0.34, 0.33, 0.00, 0.33, 0.00 }, /* 6 channels */
};
static const float mixf_r[4][6] = /* [i_src_c - 3][channel index] */
static const float mixf_r[4][6] =/* [i_src_c - 3][channel index] */
{
{ 0.00, 1.00, 0.00, 0.00, 0.00, 0.00 }, /* 3 channels */
{ 0.00, 0.00, 0.50, 0.50, 0.00, 0.00 }, /* 4 channels */
......@@ -1297,7 +1183,7 @@ static int transcode_audio_ffmpeg_process( sout_stream_t *p_stream,
}
aout_buf.i_nb_bytes = i * 2 * 2;
}
else if( id->f_src.audio.i_channels !=
else if( id->p_decoder->fmt_in.audio.i_channels !=
id->p_encoder->fmt_in.audio.i_channels )
{
unsigned int i;
......@@ -1320,8 +1206,8 @@ static int transcode_audio_ffmpeg_process( sout_stream_t *p_stream,
for( j = 0 ; j < id->p_encoder->fmt_in.audio.i_channels; j++ )
{
p_buffer[i*id->p_encoder->fmt_in.audio.i_channels+j] =
p_buffer[i*id->f_src.audio.i_channels+
translation[id->f_src.audio.i_channels][j]];
p_buffer[i*id->p_decoder->fmt_in.audio.i_channels +
translation[id->p_decoder->fmt_in.audio.i_channels][j]];
}
}
aout_buf.i_nb_bytes = i*id->p_encoder->fmt_in.audio.i_channels * 2;
......@@ -1338,213 +1224,77 @@ static int transcode_audio_ffmpeg_process( sout_stream_t *p_stream,
/*
* video
*/
static int transcode_video_ffmpeg_new( sout_stream_t *p_stream,
sout_stream_id_t *id )
static int transcode_video_new( sout_stream_t *p_stream, sout_stream_id_t *id )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
int i_ff_codec;
/* Open decoder */
if( id->f_src.i_codec == VLC_FOURCC( 'I', '4', '2', '0' ) ||
id->f_src.i_codec == VLC_FOURCC( 'I', '4', '2', '2' ) ||
id->f_src.i_codec == VLC_FOURCC( 'I', '4', '4', '4' ) ||
id->f_src.i_codec == VLC_FOURCC( 'Y', 'V', '1', '2' ) ||
id->f_src.i_codec == VLC_FOURCC( 'Y', 'U', 'Y', '2' ) ||
id->f_src.i_codec == VLC_FOURCC( 'I', 'Y', 'U', 'V' ) ||
id->f_src.i_codec == VLC_FOURCC( 'R', 'V', '1', '5' ) ||
id->f_src.i_codec == VLC_FOURCC( 'R', 'V', '1', '6' ) ||
id->f_src.i_codec == VLC_FOURCC( 'R', 'V', '2', '4' ) ||
id->f_src.i_codec == VLC_FOURCC( 'R', 'V', '3', '2' ) ||
id->f_src.i_codec == VLC_FOURCC( 'G', 'R', 'E', 'Y' ) )
{
id->ff_dec = NULL;
id->ff_dec_c = avcodec_alloc_context();
id->ff_dec_c->width = id->f_src.video.i_width;
id->ff_dec_c->height = id->f_src.video.i_height;
id->ff_dec_c->pix_fmt = get_ff_chroma( id->f_src.i_codec );
#if LIBAVCODEC_BUILD >= 4687
if( id->ff_dec_c->width )
id->ff_dec_c->sample_aspect_ratio =
av_d2q( id->f_src.video.i_aspect / (double)VOUT_ASPECT_FACTOR *
id->ff_dec_c->height / id->ff_dec_c->width, 255 );
#else
id->ff_dec_c->aspect_ratio =
id->f_src.video.i_aspect / (float)VOUT_ASPECT_FACTOR;
#endif
}
else
{
/* find decoder */
i_ff_codec = get_ff_codec( id->f_src.i_codec );
if( i_ff_codec == 0 )
{
msg_Err( p_stream, "cannot find decoder" );
return VLC_EGENERIC;
}
id->ff_dec = avcodec_find_decoder( i_ff_codec );
if( !id->ff_dec )
{
msg_Err( p_stream, "cannot find decoder" );
return VLC_EGENERIC;
}
id->ff_dec_c = avcodec_alloc_context();
id->ff_dec_c->width = id->f_src.video.i_width;
id->ff_dec_c->height = id->f_src.video.i_height;
id->ff_dec_c->bits_per_sample=id->f_src.video.i_bits_per_pixel;
/* id->ff_dec_c->bit_rate = id->f_src.i_bitrate; */
if( id->f_src.i_extra > 0 )
{
if( i_ff_codec == CODEC_ID_SVQ3 )
{
int i_size = id->f_src.i_extra;
uint8_t *p;
id->ff_dec_c->extradata_size = i_size + 12;
p = id->ff_dec_c->extradata = malloc( i_size + 12 );
memcpy( &p[0], "SVQ3", 4 );
memset( &p[4], 0, 8 );
memcpy( &p[12], id->f_src.p_extra, i_size );
/* Now remove all atoms before the SMI one */
if( id->ff_dec_c->extradata_size > 0x5a && strncmp( &p[0x56], "SMI ", 4 ) )
{
uint8_t *psz = &p[0x52];
/*
* Open decoder
*/
while( psz < &p[id->ff_dec_c->extradata_size - 8] )
{
int i_size = GetDWBE( psz );
if( i_size <= 1 )
{
/* FIXME handle 1 as long size */
break;
}
if( !strncmp( &psz[4], "SMI ", 4 ) )
{
memmove( &p[0x52], psz, &p[id->ff_dec_c->extradata_size] - psz );
break;
}
psz += i_size;
}
}
}
else
{
id->ff_dec_c->extradata_size= id->f_src.i_extra;
id->ff_dec_c->extradata = malloc( id->f_src.i_extra + FF_INPUT_BUFFER_PADDING_SIZE );
/* Initialization of decoder structures */
id->p_decoder->pf_decode_video = 0;
id->p_decoder->pf_vout_buffer_new = video_new_buffer;
id->p_decoder->pf_vout_buffer_del = video_del_buffer;
id->p_decoder->pf_picture_link = video_link_picture;
id->p_decoder->pf_picture_unlink = video_unlink_picture;
//id->p_decoder->p_cfg = p_sys->p_video_cfg;
memcpy( id->ff_dec_c->extradata, id->f_src.p_extra, id->f_src.i_extra );
memset( (uint8_t*)id->ff_dec_c->extradata + id->f_src.i_extra, 0, FF_INPUT_BUFFER_PADDING_SIZE );
}
}
id->ff_dec_c->workaround_bugs = FF_BUG_AUTODETECT;
id->ff_dec_c->error_resilience= -1;
id->ff_dec_c->get_buffer = transcode_video_ffmpeg_getframebuf;
id->ff_dec_c->opaque = p_sys;
id->p_decoder->p_module =
module_Need( id->p_decoder, "decoder", "$codec", 0 );
if( avcodec_open( id->ff_dec_c, id->ff_dec ) < 0 )
if( !id->p_decoder->p_module )
{
msg_Err( p_stream, "cannot open decoder" );
av_free( id->ff_dec_c );
msg_Err( p_stream, "cannot find decoder" );
return VLC_EGENERIC;
}
}
/* Open encoder */
id->p_encoder = vlc_object_create( p_stream, VLC_OBJECT_ENCODER );
/*
* Open encoder.
* Because some info about the decoded input will only be available
* once the first frame is decoded, we actually only test the availability
* of the encoder here.
*/
/* Initialization of encoder format structures */
es_format_Init( &id->p_encoder->fmt_in,
id->f_src.i_cat, get_vlc_chroma(id->ff_dec_c->pix_fmt) );
es_format_Init( &id->p_encoder->fmt_in, id->p_decoder->fmt_in.i_cat,
id->p_decoder->fmt_out.i_codec );
id->p_encoder->fmt_in.video.i_chroma = id->p_decoder->fmt_out.i_codec;
/* The dimensions will be set properly later on.
* Just put sensible values so we can test if there is an encoder. */
* Just put sensible values so we can test an encoder is available. */
id->p_encoder->fmt_in.video.i_width =
id->f_src.video.i_width ? id->f_src.video.i_width : 16;
id->p_encoder->fmt_out.video.i_width ?
id->p_encoder->fmt_out.video.i_width :
id->p_decoder->fmt_in.video.i_width ?
id->p_decoder->fmt_in.video.i_width : 16;
id->p_encoder->fmt_in.video.i_height =
id->f_src.video.i_height ? id->f_src.video.i_height : 16;
id->p_encoder->fmt_in.video.i_frame_rate = 25; /* FIXME as it break mpeg */
id->p_encoder->fmt_in.video.i_frame_rate_base= 1;
if( id->ff_dec )
{
id->p_encoder->fmt_in.video.i_frame_rate = id->ff_dec_c->frame_rate;
#if LIBAVCODEC_BUILD >= 4662
id->p_encoder->fmt_in.video.i_frame_rate_base =
id->ff_dec_c->frame_rate_base;
#endif
#if LIBAVCODEC_BUILD >= 4687
if( id->ff_dec_c->height )
id->p_encoder->fmt_in.video.i_aspect = VOUT_ASPECT_FACTOR *
( av_q2d(id->ff_dec_c->sample_aspect_ratio) *
id->ff_dec_c->width / id->ff_dec_c->height );
#else
id->p_encoder->fmt_in.video.i_aspect = VOUT_ASPECT_FACTOR *
id->ff_dec_c->aspect_ratio;
#endif
}
/* Override with user settings */
if( p_sys->f_fps > 0 )
{
id->p_encoder->fmt_in.video.i_frame_rate = p_sys->f_fps * 1000;
id->p_encoder->fmt_in.video.i_frame_rate_base = 1000;
}
id->f_dst.video.i_frame_rate = id->p_encoder->fmt_in.video.i_frame_rate;
id->f_dst.video.i_frame_rate_base =
id->p_encoder->fmt_in.video.i_frame_rate_base;
/* Check whether a particular aspect ratio was requested */
if( id->f_src.video.i_aspect )
{
id->p_encoder->fmt_in.video.i_aspect = id->f_src.video.i_aspect;
id->f_dst.video.i_aspect = id->f_src.video.i_aspect;
}
id->p_encoder->fmt_out = id->p_encoder->fmt_in;
id->p_encoder->fmt_out.i_codec = id->f_dst.i_codec;
id->p_encoder->fmt_out.i_bitrate = id->f_dst.i_bitrate;
id->p_encoder->fmt_out.video.i_height ?
id->p_encoder->fmt_out.video.i_height :
id->p_decoder->fmt_in.video.i_height ?
id->p_decoder->fmt_in.video.i_height : 16;
id->p_encoder->fmt_in.video.i_frame_rate = 25;
id->p_encoder->fmt_in.video.i_frame_rate_base = 1;
id->p_encoder->i_threads = p_sys->i_threads;
id->p_ff_pic = avcodec_alloc_frame();
id->p_ff_pic_tmp0 = NULL;
id->p_ff_pic_tmp1 = NULL;
id->p_ff_pic_tmp2 = NULL;
id->p_ff_pic_tmp3 = NULL;
id->p_vresample = NULL;
id->p_encoder->p_cfg = p_sys->p_video_cfg;
/* Attach object to parent so object variables inheritance works */
vlc_object_attach( id->p_encoder, p_stream );
id->p_encoder->p_module =
module_Need( id->p_encoder, "encoder", p_sys->psz_venc, VLC_TRUE );
if( !id->p_encoder->p_module )
{
vlc_object_detach( id->p_encoder );
vlc_object_destroy( id->p_encoder );
av_free( id->ff_dec_c );
msg_Err( p_stream, "cannot find encoder" );
module_Unneed( id->p_decoder, id->p_decoder->p_module );
id->p_decoder->p_module = 0;
return VLC_EGENERIC;
}
/* Close the encoder.
* We'll open it only when we have the first frame */
* We'll open it only when we have the first frame. */
module_Unneed( id->p_encoder, id->p_encoder->p_module );
id->p_encoder->p_module = NULL;
id->b_enc_inited = VLC_FALSE;
if ( p_sys->i_threads >= 1 )
if( p_sys->i_threads >= 1 )
{
p_sys->id_video = id;
vlc_mutex_init( p_stream, &p_sys->lock_out );
......@@ -1557,10 +1307,9 @@ static int transcode_video_ffmpeg_new( sout_stream_t *p_stream,
if( vlc_thread_create( p_sys, "encoder", EncoderThread,
VLC_THREAD_PRIORITY_VIDEO, VLC_FALSE ) )
{
vlc_object_detach( id->p_encoder );
vlc_object_destroy( id->p_encoder );
av_free( id->ff_dec_c );
msg_Err( p_stream, "cannot spawn encoder thread" );
module_Unneed( id->p_decoder, id->p_decoder->p_module );
id->p_decoder->p_module = 0;
return VLC_EGENERIC;
}
}
......@@ -1568,144 +1317,163 @@ static int transcode_video_ffmpeg_new( sout_stream_t *p_stream,
return VLC_SUCCESS;
}
static void transcode_video_ffmpeg_close ( sout_stream_t *p_stream,
static int transcode_video_encoder_open( sout_stream_t *p_stream,
sout_stream_id_t *id )
{
if ( p_stream->p_sys->i_threads >= 1 )
{
vlc_mutex_lock( &p_stream->p_sys->lock_out );
p_stream->p_sys->b_die = 1;
vlc_cond_signal( &p_stream->p_sys->cond );
vlc_mutex_unlock( &p_stream->p_sys->lock_out );
vlc_thread_join( p_stream->p_sys );
vlc_mutex_destroy( &p_stream->p_sys->lock_out );
vlc_cond_destroy( &p_stream->p_sys->cond );
}
/* Close decoder */
if( id->ff_dec ) avcodec_close( id->ff_dec_c );
av_free( id->ff_dec_c );
sout_stream_sys_t *p_sys = p_stream->p_sys;
/* Close encoder */
if( id->p_encoder->p_module )
module_Unneed( id->p_encoder, id->p_encoder->p_module );
vlc_object_detach( id->p_encoder );
vlc_object_destroy( id->p_encoder );
/* Hack because of the copy packetizer which can fail to detect the
* proper size (which forces us to wait until the 1st frame
* is decoded) */
int i_width = id->p_decoder->fmt_out.video.i_width -
p_sys->i_crop_left - p_sys->i_crop_right;
int i_height = id->p_decoder->fmt_out.video.i_height -
p_sys->i_crop_top - p_sys->i_crop_bottom;
/* Misc cleanup */
if( id->p_ff_pic)
if( id->p_encoder->fmt_out.video.i_width <= 0 &&
id->p_encoder->fmt_out.video.i_height <= 0 && p_sys->f_scale )
{
free( id->p_ff_pic );
/* Apply the scaling */
id->p_encoder->fmt_out.video.i_width = i_width * p_sys->f_scale;
id->p_encoder->fmt_out.video.i_height = i_height * p_sys->f_scale;
}
if( id->p_ff_pic_tmp0 )
else if( id->p_encoder->fmt_out.video.i_width > 0 &&
id->p_encoder->fmt_out.video.i_height <= 0 )
{
free( id->p_ff_pic_tmp0->data[0] );
free( id->p_ff_pic_tmp0 );
id->p_encoder->fmt_out.video.i_height =
id->p_encoder->fmt_out.video.i_width / (double)i_width * i_height;
}
if( id->p_ff_pic_tmp1 )
else if( id->p_encoder->fmt_out.video.i_width <= 0 &&
id->p_encoder->fmt_out.video.i_height > 0 )
{
free( id->p_ff_pic_tmp1->data[0] );
free( id->p_ff_pic_tmp1 );
id->p_encoder->fmt_out.video.i_width =
id->p_encoder->fmt_out.video.i_height / (double)i_height * i_width;
}
if( id->p_ff_pic_tmp2 )
id->p_encoder->fmt_in.video.i_width =
id->p_encoder->fmt_out.video.i_width;
id->p_encoder->fmt_in.video.i_height =
id->p_encoder->fmt_out.video.i_height;
if( !id->p_encoder->fmt_out.video.i_frame_rate ||
!id->p_encoder->fmt_out.video.i_frame_rate_base )
{
free( id->p_ff_pic_tmp2->data[0] );
free( id->p_ff_pic_tmp2 );
}
if( id->p_ff_pic_tmp3 )
if( id->p_decoder->fmt_out.video.i_frame_rate &&
id->p_decoder->fmt_out.video.i_frame_rate_base )
{
free( id->p_ff_pic_tmp3->data[0] );
free( id->p_ff_pic_tmp3 );
id->p_encoder->fmt_out.video.i_frame_rate =
id->p_decoder->fmt_out.video.i_frame_rate;
id->p_encoder->fmt_out.video.i_frame_rate_base =
id->p_decoder->fmt_out.video.i_frame_rate_base;
}
if( id->p_vresample )
else
{
img_resample_close( id->p_vresample );
/* Pick a sensible default value */
id->p_encoder->fmt_out.video.i_frame_rate = 25;
id->p_encoder->fmt_out.video.i_frame_rate_base = 1;
}
}
}
static int transcode_video_ffmpeg_process( sout_stream_t *p_stream,
sout_stream_id_t *id, block_t *in, block_t **out )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
int i_used, b_gotpicture, i_duplicate = 1;
AVFrame *frame;
mtime_t i_pts;
int i_data;
uint8_t *p_data;
*out = NULL;
id->p_encoder->fmt_in.video.i_frame_rate =
id->p_encoder->fmt_out.video.i_frame_rate;
id->p_encoder->fmt_in.video.i_frame_rate_base =
id->p_encoder->fmt_out.video.i_frame_rate_base;
i_data = in->i_buffer;
p_data = in->p_buffer;
date_Init( &id->interpolated_pts,
id->p_encoder->fmt_out.video.i_frame_rate,
id->p_encoder->fmt_out.video.i_frame_rate_base );
for( ;; )
/* Check whether a particular aspect ratio was requested */
if( !id->p_encoder->fmt_out.video.i_aspect )
{
block_t *p_block;
picture_t * p_pic;
int i_plane;
subpicture_t *p_subpic = 0;
id->p_encoder->fmt_out.video.i_aspect =
id->p_decoder->fmt_out.video.i_aspect;
}
id->p_encoder->fmt_in.video.i_aspect =
id->p_encoder->fmt_out.video.i_aspect;
/* decode frame */
frame = id->p_ff_pic;
p_sys->i_input_pts = in->i_pts;
p_sys->i_input_dts = in->i_dts;
if( id->ff_dec )
id->p_encoder->p_module =
module_Need( id->p_encoder, "encoder", p_sys->psz_venc, VLC_TRUE );
if( !id->p_encoder->p_module )
{
i_used = avcodec_decode_video( id->ff_dec_c, frame,
&b_gotpicture,
p_data, i_data );
msg_Err( p_stream, "cannot find encoder" );
return VLC_EGENERIC;
}
else
{
/* raw video */
avpicture_fill( (AVPicture*)frame, p_data,
id->ff_dec_c->pix_fmt,
id->ff_dec_c->width, id->ff_dec_c->height );
i_used = i_data;
b_gotpicture = 1;
/* Set PTS */
frame->pts = p_sys->i_input_pts ? p_sys->i_input_pts :
AV_NOPTS_VALUE;
id->p_encoder->fmt_in.video.i_chroma = id->p_encoder->fmt_in.i_codec;
frame->pict_type = FF_I_TYPE;
/* Hack for mp2v/mp1v transcoding support */
if( id->p_encoder->fmt_out.i_codec == VLC_FOURCC('m','p','1','v') ||
id->p_encoder->fmt_out.i_codec == VLC_FOURCC('m','p','2','v') )
{
id->p_encoder->fmt_out.i_codec = VLC_FOURCC('m','p','g','v');
}
if( i_used < 0 )
id->id = p_stream->p_sys->p_out->pf_add( p_stream->p_sys->p_out,
&id->p_encoder->fmt_out );
if( !id->id )
{
msg_Warn( p_stream, "error");
msg_Err( p_stream, "cannot add this stream" );
return VLC_EGENERIC;
}
i_data -= i_used;
p_data += i_used;
if( !b_gotpicture )
{
return VLC_SUCCESS;
}
}
static void transcode_video_close( sout_stream_t *p_stream,
sout_stream_id_t *id )
{
int i;
/* Get the pts of the decoded frame if any, otherwise keep the
* interpolated one */
if( frame->pts != AV_NOPTS_VALUE )
if( p_stream->p_sys->i_threads >= 1 )
{
p_sys->i_output_pts = frame->pts;
vlc_mutex_lock( &p_stream->p_sys->lock_out );
p_stream->p_sys->b_die = 1;
vlc_cond_signal( &p_stream->p_sys->cond );
vlc_mutex_unlock( &p_stream->p_sys->lock_out );
vlc_thread_join( p_stream->p_sys );
vlc_mutex_destroy( &p_stream->p_sys->lock_out );
vlc_cond_destroy( &p_stream->p_sys->cond );
}
i_pts = p_sys->i_output_pts;
/* Sanity check (seems to be needed for some streams ) */
if( frame->pict_type == FF_B_TYPE )
/* Close decoder */
if( id->p_decoder->p_module )
module_Unneed( id->p_decoder, id->p_decoder->p_module );
/* Close encoder */
if( id->p_encoder->p_module )
module_Unneed( id->p_encoder, id->p_encoder->p_module );
/* Close filters */
for( i = 0; i < id->i_filter; i++ )
{
p_sys->b_input_has_b_frames = VLC_TRUE;
vlc_object_detach( id->pp_filter[i] );
if( id->pp_filter[i]->p_module )
module_Unneed( id->pp_filter[i], id->pp_filter[i]->p_module );
vlc_object_destroy( id->pp_filter[i] );
}
}
static int transcode_video_process( sout_stream_t *p_stream,
sout_stream_id_t *id,
block_t *in, block_t **out )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
int i_duplicate = 1, i;
picture_t *p_pic;
*out = NULL;
while( (p_pic = id->p_decoder->pf_decode_video( id->p_decoder, &in )) )
{
subpicture_t *p_subpic = 0;
if( p_sys->b_audio_sync )
{
mtime_t i_video_drift;
mtime_t i_master_drift = p_sys->i_master_drift;
mtime_t i_pts;
if( !id->i_initial_pts ) id->i_initial_pts = p_sys->i_output_pts;
if( !id->i_initial_pts ) id->i_initial_pts = p_pic->date;
if( !i_master_drift )
{
......@@ -1714,9 +1482,12 @@ static int transcode_video_ffmpeg_process( sout_stream_t *p_stream,
}
i_pts = date_Get( &id->interpolated_pts ) + 1;
i_video_drift = p_sys->i_output_pts - i_pts;
i_video_drift = p_pic->date - i_pts;
i_duplicate = 1;
/* Set the pts of the frame being encoded */
p_pic->date = i_pts;
if( i_video_drift < i_master_drift - 50000 )
{
msg_Dbg( p_stream, "dropping frame (%i)",
......@@ -1733,278 +1504,65 @@ static int transcode_video_ffmpeg_process( sout_stream_t *p_stream,
date_Increment( &id->interpolated_pts, 1 );
}
if( !id->b_enc_inited )
{
/* Hack because of the copy packetizer which can fail to detect the
* proper size (which forces us to wait until the 1st frame
* is decoded) */
int i_width = id->ff_dec_c->width - p_sys->i_crop_left -
p_sys->i_crop_right;
int i_height = id->ff_dec_c->height - p_sys->i_crop_top -
p_sys->i_crop_bottom;
if( id->f_dst.video.i_width <= 0 && id->f_dst.video.i_height <= 0
&& p_sys->f_scale )
{
/* Apply the scaling */
id->f_dst.video.i_width = i_width * p_sys->f_scale;
id->f_dst.video.i_height = i_height * p_sys->f_scale;
}
else if( id->f_dst.video.i_width > 0 &&
id->f_dst.video.i_height <= 0 )
{
id->f_dst.video.i_height =
id->f_dst.video.i_width / (double)i_width * i_height;
}
else if( id->f_dst.video.i_width <= 0 &&
id->f_dst.video.i_height > 0 )
{
id->f_dst.video.i_width =
id->f_dst.video.i_height / (double)i_height * i_width;
}
id->p_encoder->fmt_in.video.i_width = id->f_dst.video.i_width;
id->p_encoder->fmt_in.video.i_height = id->f_dst.video.i_height;
id->p_encoder->fmt_out = id->f_dst;
id->p_encoder->p_module =
module_Need( id->p_encoder, "encoder",
p_sys->psz_venc, VLC_TRUE );
if( !id->p_encoder->p_module )
{
vlc_object_destroy( id->p_encoder );
msg_Err( p_stream, "cannot find encoder" );
id->b_transcode = VLC_FALSE;
return VLC_EGENERIC;
}
id->f_dst = id->p_encoder->fmt_out;
/* Hack for mp2v/mp1v transcoding support */
if( id->f_dst.i_codec == VLC_FOURCC( 'm','p','1','v' ) ||
id->f_dst.i_codec == VLC_FOURCC( 'm','p','2','v' ) )
{
id->f_dst.i_codec = VLC_FOURCC( 'm','p','g','v' );
}
if( !( id->id =
p_stream->p_sys->p_out->pf_add( p_stream->p_sys->p_out,
&id->f_dst ) ) )
if( transcode_video_encoder_open( p_stream, id ) != VLC_SUCCESS )
{
msg_Err( p_stream, "cannot add this stream" );
transcode_video_ffmpeg_close( p_stream, id );
transcode_video_close( p_stream, id );
id->b_transcode = VLC_FALSE;
return VLC_EGENERIC;
}
if( id->p_encoder->pf_header )
/* Check if we need a filter for chroma conversion or resizing */
if( id->p_decoder->fmt_out.video.i_chroma !=
id->p_encoder->fmt_in.video.i_chroma ||
id->p_decoder->fmt_out.video.i_width !=
id->p_encoder->fmt_out.video.i_width ||
id->p_decoder->fmt_out.video.i_height !=
id->p_encoder->fmt_out.video.i_height ||
p_sys->i_crop_top > 0 || p_sys->i_crop_bottom > 0 ||
p_sys->i_crop_left > 0 || p_sys->i_crop_right > 0 )
{
block_t *p_block_tmp;
id->pp_filter[0] =
vlc_object_create( p_stream, VLC_OBJECT_FILTER );
vlc_object_attach( id->pp_filter[0], p_stream );
p_block = id->p_encoder->pf_header( id->p_encoder );
p_block_tmp = p_block;
while( p_block_tmp )
id->pp_filter[0]->pf_vout_buffer_new = video_new_buffer;
id->pp_filter[0]->pf_vout_buffer_del = video_del_buffer;
id->pp_filter[0]->fmt_in = id->p_decoder->fmt_out;
id->pp_filter[0]->fmt_out = id->p_encoder->fmt_in;
id->pp_filter[0]->p_module =
module_Need( id->pp_filter[0], "video filter2", 0, 0 );
if( id->pp_filter[0]->p_module ) id->i_filter++;
else
{
p_block_tmp->i_dts = p_block_tmp->i_pts = in->i_dts;
p_block_tmp = p_block_tmp->p_next;
msg_Dbg( p_stream, "no video filter found" );
vlc_object_detach( id->pp_filter[0] );
vlc_object_destroy( id->pp_filter[0] );
}
block_ChainAppend( out, p_block );
}
id->i_inter_pixfmt =
get_ff_chroma( id->p_encoder->fmt_in.i_codec );
id->b_enc_inited = VLC_TRUE;
}
/* deinterlace */
/* Deinterlace */
if( p_stream->p_sys->b_deinterlace )
{
if( id->p_ff_pic_tmp0 == NULL )
{
int i_size;
uint8_t *buf;
id->p_ff_pic_tmp0 = avcodec_alloc_frame();
i_size = avpicture_get_size( id->ff_dec_c->pix_fmt,
id->ff_dec_c->width,
id->ff_dec_c->height );
buf = malloc( i_size );
avpicture_fill( (AVPicture*)id->p_ff_pic_tmp0, buf,
id->i_inter_pixfmt,
id->ff_dec_c->width, id->ff_dec_c->height );
}
avpicture_deinterlace( (AVPicture*)id->p_ff_pic_tmp0,
(AVPicture*)frame, id->ff_dec_c->pix_fmt,
id->ff_dec_c->width, id->ff_dec_c->height );
#if LIBAVCODEC_BUILD >= 4685
id->p_ff_pic_tmp0->interlaced_frame = 0;
#endif
id->p_ff_pic_tmp0->repeat_pict = frame->repeat_pict;
frame = id->p_ff_pic_tmp0;
}
/* convert pix format */
if( id->ff_dec_c->pix_fmt != id->i_inter_pixfmt )
{
if( id->p_ff_pic_tmp1 == NULL )
{
int i_size;
uint8_t *buf;
id->p_ff_pic_tmp1 = avcodec_alloc_frame();
i_size = avpicture_get_size( id->i_inter_pixfmt,
id->ff_dec_c->width,
id->ff_dec_c->height );
buf = malloc( i_size );
avpicture_fill( (AVPicture*)id->p_ff_pic_tmp1, buf,
id->i_inter_pixfmt,
id->ff_dec_c->width, id->ff_dec_c->height );
}
img_convert( (AVPicture*)id->p_ff_pic_tmp1, id->i_inter_pixfmt,
(AVPicture*)frame, id->ff_dec_c->pix_fmt,
id->ff_dec_c->width, id->ff_dec_c->height );
id->p_ff_pic_tmp1->repeat_pict = frame->repeat_pict;
#if LIBAVCODEC_BUILD >= 4685
id->p_ff_pic_tmp1->interlaced_frame = frame->interlaced_frame;
id->p_ff_pic_tmp1->top_field_first = frame->top_field_first;
#endif
frame = id->p_ff_pic_tmp1;
}
/* convert size and crop */
if( id->ff_dec_c->width != id->f_dst.video.i_width ||
id->ff_dec_c->height != id->f_dst.video.i_height ||
p_sys->i_crop_top > 0 || p_sys->i_crop_bottom > 0 ||
p_sys->i_crop_left > 0 || p_sys->i_crop_right > 0 )
/* Run filter chain */
for( i = 0; i < id->i_filter; i++ )
{
if( id->p_ff_pic_tmp2 == NULL )
{
int i_size;
uint8_t *buf;
id->p_ff_pic_tmp2 = avcodec_alloc_frame();
i_size = avpicture_get_size( id->i_inter_pixfmt,
id->f_dst.video.i_width,
id->f_dst.video.i_height );
buf = malloc( i_size );
avpicture_fill( (AVPicture*)id->p_ff_pic_tmp2, buf,
id->i_inter_pixfmt,
id->f_dst.video.i_width,
id->f_dst.video.i_height );
id->p_vresample =
img_resample_full_init( id->f_dst.video.i_width,
id->f_dst.video.i_height,
id->ff_dec_c->width,
id->ff_dec_c->height,
p_stream->p_sys->i_crop_top,
p_stream->p_sys->i_crop_bottom,
p_stream->p_sys->i_crop_left,
p_stream->p_sys->i_crop_right
#if LIBAVCODEC_BUILD >= 4708
,0, 0, 0, 0 );
#else
);
#endif
p_pic = id->pp_filter[i]->pf_video_filter(id->pp_filter[i], p_pic);
}
img_resample( id->p_vresample, (AVPicture*)id->p_ff_pic_tmp2,
(AVPicture*)frame );
id->p_ff_pic_tmp2->repeat_pict = frame->repeat_pict;
#if LIBAVCODEC_BUILD >= 4685
id->p_ff_pic_tmp2->interlaced_frame = frame->interlaced_frame;
id->p_ff_pic_tmp2->top_field_first = frame->top_field_first;
#endif
frame = id->p_ff_pic_tmp2;
}
/* Encoding */
p_pic = malloc(sizeof(picture_t));
vout_InitPicture( VLC_OBJECT(p_stream), p_pic,
id->p_encoder->fmt_in.i_codec,
id->f_dst.video.i_width, id->f_dst.video.i_height,
id->f_dst.video.i_width * VOUT_ASPECT_FACTOR /
id->f_dst.video.i_height );
/*
* Encoding
*/
/* Check if we have a subpicture to overlay */
if( p_sys->p_filter_blend )
{
p_subpic = transcode_spu_get( p_stream, id, p_sys->i_output_pts );
if( p_subpic && frame != id->p_ff_pic_tmp0 &&
frame != id->p_ff_pic_tmp1 && frame != id->p_ff_pic_tmp2 )
{
if( id->p_ff_pic_tmp3 == NULL )
{
uint8_t *buf = malloc( frame->linesize[0] *
p_pic->p[0].i_lines * 3 );
id->p_ff_pic_tmp3 = avcodec_alloc_frame();
*id->p_ff_pic_tmp3 = *frame;
id->p_ff_pic_tmp3->data[0] = buf;
id->p_ff_pic_tmp3->data[1] = id->p_ff_pic_tmp3->data[0] +
frame->linesize[0] * p_pic->p[0].i_lines;
id->p_ff_pic_tmp3->data[2] = id->p_ff_pic_tmp3->data[1] +
frame->linesize[1] * p_pic->p[1].i_lines;
}
for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
{
p_stream->p_vlc->pf_memcpy(
id->p_ff_pic_tmp3->data[i_plane],
frame->data[i_plane],
p_pic->p[i_plane].i_lines * frame->linesize[i_plane] );
}
id->p_ff_pic_tmp3->repeat_pict = frame->repeat_pict;
#if LIBAVCODEC_BUILD >= 4685
id->p_ff_pic_tmp3->interlaced_frame = frame->interlaced_frame;
id->p_ff_pic_tmp3->top_field_first = frame->top_field_first;
#endif
frame = id->p_ff_pic_tmp3;
}
}
for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
{
p_pic->p[i_plane].i_pitch = frame->linesize[i_plane];
if ( p_sys->i_threads >= 1 )
{
p_pic->p[i_plane].p_pixels = malloc(p_pic->p[i_plane].i_lines *
p_pic->p[i_plane].i_pitch);
p_stream->p_vlc->pf_memcpy( p_pic->p[i_plane].p_pixels,
frame->data[i_plane], p_pic->p[i_plane].i_lines *
p_pic->p[i_plane].i_pitch );
}
else
{
p_pic->p[i_plane].p_pixels = frame->data[i_plane];
}
}
/* Set the pts of the frame being encoded */
p_pic->date = i_pts;
p_pic->i_nb_fields = frame->repeat_pict;
#if LIBAVCODEC_BUILD >= 4685
p_pic->b_progressive = !frame->interlaced_frame;
p_pic->b_top_field_first = frame->top_field_first;
#endif
/* Interpolate the next PTS
* (needed by the mpeg video packetizer which can send pts <= 0 ) */
if( id->ff_dec_c && id->ff_dec_c->frame_rate > 0 )
{
p_sys->i_output_pts += I64C(1000000) * (2 + frame->repeat_pict) *
id->ff_dec_c->frame_rate_base / (2 * id->ff_dec_c->frame_rate);
p_subpic = transcode_spu_get( p_stream, id, p_pic->date );
/* TODO: get another pic */
}
/* Overlay subpicture */
......@@ -2072,7 +1630,7 @@ static int transcode_video_ffmpeg_process( sout_stream_t *p_stream,
}
}
if ( p_sys->i_threads >= 1 )
if( p_sys->i_threads >= 1 )
{
vlc_mutex_lock( &p_sys->lock_out );
p_sys->pp_pics[p_sys->i_last_pic++] = p_pic;
......@@ -2090,43 +1648,37 @@ static int transcode_video_ffmpeg_process( sout_stream_t *p_stream,
if( p_sys->b_audio_sync && i_duplicate > 1 )
{
i_pts = date_Get( &id->interpolated_pts ) + 1;
mtime_t i_pts = date_Get( &id->interpolated_pts ) + 1;
date_Increment( &id->interpolated_pts, 1 );
p_pic->date = i_pts;
p_block = id->p_encoder->pf_encode_video( id->p_encoder, p_pic );
p_block = id->p_encoder->pf_encode_video(id->p_encoder, p_pic);
block_ChainAppend( out, p_block );
}
free( p_pic );
}
if( i_data <= 0 )
{
return VLC_SUCCESS;
p_pic->pf_release( p_pic );
}
}
return VLC_SUCCESS;
}
static int EncoderThread( sout_stream_sys_t * p_sys )
static int EncoderThread( sout_stream_sys_t *p_sys )
{
sout_stream_id_t * id = p_sys->id_video;
picture_t * p_pic;
sout_stream_id_t *id = p_sys->id_video;
picture_t *p_pic;
int i_plane;
while ( !p_sys->b_die && !p_sys->b_error )
while( !p_sys->b_die && !p_sys->b_error )
{
block_t *p_block;
vlc_mutex_lock( &p_sys->lock_out );
while ( p_sys->i_last_pic == p_sys->i_first_pic )
while( p_sys->i_last_pic == p_sys->i_first_pic )
{
vlc_cond_wait( &p_sys->cond, &p_sys->lock_out );
if ( p_sys->b_die || p_sys->b_error )
break;
if( p_sys->b_die || p_sys->b_error ) break;
}
if ( p_sys->b_die || p_sys->b_error )
if( p_sys->b_die || p_sys->b_error )
{
vlc_mutex_unlock( &p_sys->lock_out );
break;
......@@ -2148,7 +1700,7 @@ static int EncoderThread( sout_stream_sys_t * p_sys )
free( p_pic );
}
while ( p_sys->i_last_pic != p_sys->i_first_pic )
while( p_sys->i_last_pic != p_sys->i_first_pic )
{
p_pic = p_sys->pp_pics[p_sys->i_first_pic++];
p_sys->i_first_pic %= PICTURE_RING_SIZE;
......@@ -2165,44 +1717,59 @@ static int EncoderThread( sout_stream_sys_t * p_sys )
return 0;
}
/*****************************************************************************
* transcode_video_ffmpeg_getframebuf:
*
* Callback used by ffmpeg to get a frame buffer.
* We use it to get the right PTS for each decoded picture.
*****************************************************************************/
static int transcode_video_ffmpeg_getframebuf(struct AVCodecContext *p_context,
AVFrame *p_frame)
struct picture_sys_t
{
sout_stream_sys_t *p_sys = (sout_stream_sys_t *)p_context->opaque;
decoder_t *p_dec;
};
/* Set PTS */
if( p_sys->i_input_pts )
{
p_frame->pts = p_sys->i_input_pts;
}
else if( p_sys->i_input_dts )
{
/* Some demuxers/packetizers only set the dts so let's try to find a
* useful timestamp from this */
if( !p_context->has_b_frames || !p_sys->b_input_has_b_frames ||
!p_frame->reference || !p_sys->i_output_pts )
static void video_release_buffer( picture_t *p_pic )
{
if( p_pic && !p_pic->i_refcount && p_pic->pf_release && p_pic->p_sys )
{
p_frame->pts = p_sys->i_input_dts +
/* Hack: ffmpeg encoding doesn't like frames with identical pts */
(p_sys->i_output_pts ? 0 : 50000);
}
else p_frame->pts = AV_NOPTS_VALUE;
video_del_buffer( p_pic->p_sys->p_dec, p_pic );
}
else p_frame->pts = AV_NOPTS_VALUE;
else if( p_pic && p_pic->i_refcount > 0 ) p_pic->i_refcount--;
}
static picture_t *video_new_buffer( decoder_t *p_dec )
{
picture_t *p_pic = malloc( sizeof(picture_t) );
p_dec->fmt_out.video.i_chroma = p_dec->fmt_out.i_codec;
vout_AllocatePicture( VLC_OBJECT(p_dec), p_pic,
p_dec->fmt_out.video.i_chroma,
p_dec->fmt_out.video.i_width,
p_dec->fmt_out.video.i_height,
p_dec->fmt_out.video.i_aspect );
if( p_sys->i_output_pts ) /* make sure 1st frame has a pts > 0 */
if( !p_pic->i_planes )
{
p_sys->i_input_pts = 0;
p_sys->i_input_dts = 0;
free( p_pic );
return 0;
}
return avcodec_default_get_buffer( p_context, p_frame );
p_pic->pf_release = video_release_buffer;
p_pic->p_sys = malloc( sizeof(picture_sys_t) );
p_pic->p_sys->p_dec = p_dec;
return p_pic;
}
static void video_del_buffer( decoder_t *p_dec, picture_t *p_pic )
{
if( p_pic && p_pic->p_data ) free( p_pic->p_data );
if( p_pic && p_pic->p_sys ) free( p_pic->p_sys );
if( p_pic ) free( p_pic );
}
static void video_link_picture( decoder_t *p_dec, picture_t *p_pic )
{
p_pic->i_refcount++;
}
static void video_unlink_picture( decoder_t *p_dec, picture_t *p_pic )
{
video_release_buffer( p_pic );
}
/*
......@@ -2215,66 +1782,50 @@ static int transcode_spu_new( sout_stream_t *p_stream, sout_stream_id_t *id )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
/* Open decoder */
id->p_decoder = vlc_object_create( p_stream, VLC_OBJECT_DECODER );
/*
* Open decoder
*/
/* Initialization of decoder format structures */
id->p_decoder->fmt_in = id->f_src;
/* Initialization of decoder structures */
id->p_decoder->pf_spu_buffer_new = spu_new_buffer;
id->p_decoder->pf_spu_buffer_del = spu_del_buffer;
//id->p_decoder->p_cfg = p_sys->p_spu_cfg;
/* Attach object to parent so object variables inheritance works */
vlc_object_attach( id->p_decoder, p_stream );
id->p_decoder->p_module =
module_Need( id->p_decoder, "decoder", "$codec", VLC_TRUE );
module_Need( id->p_decoder, "decoder", "$codec", 0 );
if( !id->p_decoder->p_module )
{
vlc_object_detach( id->p_decoder );
vlc_object_destroy( id->p_decoder );
msg_Err( p_stream, "cannot find decoder" );
return VLC_EGENERIC;
}
if( !p_sys->b_soverlay )
{
/* Open encoder */
id->p_encoder = vlc_object_create( p_stream, VLC_OBJECT_ENCODER );
/*
* Open encoder
*/
/* Initialization of encoder format structures */
es_format_Init( &id->p_encoder->fmt_in,
id->f_src.i_cat, id->f_src.i_codec );
id->p_encoder->fmt_out = id->f_dst;
es_format_Init( &id->p_encoder->fmt_in, id->p_decoder->fmt_in.i_cat,
id->p_decoder->fmt_in.i_codec );
id->p_encoder->p_cfg = p_sys->p_spu_cfg;
/* Attach object to parent so object variables inheritance works */
vlc_object_attach( id->p_encoder, p_stream );
id->p_encoder->p_module =
module_Need( id->p_encoder, "encoder", p_sys->psz_senc, VLC_TRUE );
if( !id->p_encoder->p_module )
{
module_Unneed( id->p_decoder, id->p_decoder->p_module );
vlc_object_detach( id->p_decoder );
vlc_object_destroy( id->p_decoder );
vlc_object_detach( id->p_encoder );
vlc_object_destroy( id->p_encoder );
msg_Err( p_stream, "cannot find encoder" );
return VLC_EGENERIC;
}
id->f_dst = id->p_encoder->fmt_out;
}
else
{
p_sys->p_filter_blend =
vlc_object_create( p_stream, sizeof(filter_t) );
vlc_object_create( p_stream, VLC_OBJECT_FILTER );
vlc_object_attach( p_sys->p_filter_blend, p_stream );
p_sys->p_filter_blend->fmt_out.video.i_chroma =
VLC_FOURCC('I','4','2','0');
......@@ -2295,17 +1846,10 @@ static void transcode_spu_close( sout_stream_t *p_stream, sout_stream_id_t *id)
/* Close decoder */
if( id->p_decoder->p_module )
module_Unneed( id->p_decoder, id->p_decoder->p_module );
vlc_object_detach( id->p_decoder );
vlc_object_destroy( id->p_decoder );
/* Close encoder */
if( id->p_encoder )
{
if( id->p_encoder->p_module )
module_Unneed( id->p_encoder, id->p_encoder->p_module );
vlc_object_detach( id->p_encoder );
vlc_object_destroy( id->p_encoder );
}
/* Free subpictures */
for( i = 0; i < SUBPICTURE_RING_SIZE; i++ )
......
src/misc/objects.c
View file @ f2c55479
......@@ -47,6 +47,7 @@
#include "vlc_playlist.h"
#include "vlc_interface.h"
#include "vlc_codec.h"
#include "vlc_filter.h"
#include "vlc_httpd.h"
#include "vlc_vlm.h"
......@@ -149,6 +150,10 @@ void * __vlc_object_create( vlc_object_t *p_this, int i_type )
i_size = sizeof(encoder_t);
psz_type = "encoder";
break;
case VLC_OBJECT_FILTER:
i_size = sizeof(filter_t);
psz_type = "filter";
break;
case VLC_OBJECT_VOUT:
i_size = sizeof(vout_thread_t);
psz_type = "video output";
......@@ -194,12 +199,7 @@ void * __vlc_object_create( vlc_object_t *p_this, int i_type )
else
{
p_new = malloc( i_size );
if( !p_new )
{
return NULL;
}
if( !p_new ) return NULL;
memset( p_new, 0, i_size );
}
......
src/video_output/vout_pictures.c
View file @ f2c55479
......@@ -498,14 +498,18 @@ void vout_AllocatePicture( vlc_object_t *p_this, picture_t *p_pic,
vlc_fourcc_t i_chroma,
int i_width, int i_height, int i_aspect )
{
int i_bytes, i_index;
int i_bytes, i_index, i_width_aligned, i_height_aligned;
/* Make sure the real dimensions are a multiple of 16 */
i_width_aligned = (i_width + 15) >> 4 << 4;
i_height_aligned = (i_height + 15) >> 4 << 4;
vout_InitPicture( p_this, p_pic, i_chroma,
i_width, i_height, i_aspect );
/* Calculate how big the new image should be */
i_bytes = p_pic->format.i_bits_per_pixel *
p_pic->format.i_width * p_pic->format.i_height / 8;
i_width_aligned * i_height_aligned / 8;
p_pic->p_data = vlc_memalign( &p_pic->p_data_orig, 16, i_bytes );
......@@ -626,7 +630,7 @@ void vout_InitPicture( vlc_object_t *p_this, picture_t *p_pic,
vlc_fourcc_t i_chroma,
int i_width, int i_height, int i_aspect )
{
int i_index;
int i_index, i_width_aligned, i_height_aligned;
/* Store default values */
for( i_index = 0; i_index < VOUT_MAX_PLANES; i_index++ )
......@@ -635,35 +639,44 @@ void vout_InitPicture( vlc_object_t *p_this, picture_t *p_pic,
p_pic->p[i_index].i_pixel_pitch = 1;
}
p_pic->pf_release = 0;
p_pic->pf_lock = 0;
p_pic->pf_unlock = 0;
p_pic->i_refcount = 0;
vout_InitFormat( &p_pic->format, i_chroma, i_width, i_height, i_aspect );
/* Make sure the real dimensions are a multiple of 16 */
i_width_aligned = (i_width + 15) >> 4 << 4;
i_height_aligned = (i_height + 15) >> 4 << 4;
/* Calculate coordinates */
switch( i_chroma )
{
case FOURCC_I411:
p_pic->p[ Y_PLANE ].i_lines = i_height;
p_pic->p[ Y_PLANE ].i_pitch = i_width;
p_pic->p[ Y_PLANE ].i_visible_pitch = p_pic->p[ Y_PLANE ].i_pitch;
p_pic->p[ Y_PLANE ].i_pitch = i_width_aligned;
p_pic->p[ Y_PLANE ].i_visible_pitch = i_width;
p_pic->p[ U_PLANE ].i_lines = i_height;
p_pic->p[ U_PLANE ].i_pitch = i_width / 4;
p_pic->p[ U_PLANE ].i_visible_pitch = p_pic->p[ U_PLANE ].i_pitch;
p_pic->p[ U_PLANE ].i_pitch = i_width_aligned / 4;
p_pic->p[ U_PLANE ].i_visible_pitch = i_width / 4;
p_pic->p[ V_PLANE ].i_lines = i_height;
p_pic->p[ V_PLANE ].i_pitch = i_width / 4;
p_pic->p[ V_PLANE ].i_visible_pitch = p_pic->p[ V_PLANE ].i_pitch;
p_pic->p[ V_PLANE ].i_pitch = i_width_aligned / 4;
p_pic->p[ V_PLANE ].i_visible_pitch = i_width / 4;
p_pic->i_planes = 3;
break;
case FOURCC_I410:
case FOURCC_YVU9:
p_pic->p[ Y_PLANE ].i_lines = i_height;
p_pic->p[ Y_PLANE ].i_pitch = i_width;
p_pic->p[ Y_PLANE ].i_visible_pitch = p_pic->p[ Y_PLANE ].i_pitch;
p_pic->p[ Y_PLANE ].i_pitch = i_width_aligned;
p_pic->p[ Y_PLANE ].i_visible_pitch = i_width;
p_pic->p[ U_PLANE ].i_lines = i_height / 4;
p_pic->p[ U_PLANE ].i_pitch = i_width / 4;
p_pic->p[ U_PLANE ].i_visible_pitch = p_pic->p[ U_PLANE ].i_pitch;
p_pic->p[ U_PLANE ].i_pitch = i_width_aligned / 4;
p_pic->p[ U_PLANE ].i_visible_pitch = i_width / 4;
p_pic->p[ V_PLANE ].i_lines = i_height / 4;
p_pic->p[ V_PLANE ].i_pitch = i_width / 4;
p_pic->p[ V_PLANE ].i_visible_pitch = p_pic->p[ V_PLANE ].i_pitch;
p_pic->p[ V_PLANE ].i_pitch = i_width_aligned / 4;
p_pic->p[ V_PLANE ].i_visible_pitch = i_width / 4;
p_pic->i_planes = 3;
break;
......@@ -671,71 +684,71 @@ void vout_InitPicture( vlc_object_t *p_this, picture_t *p_pic,
case FOURCC_I420:
case FOURCC_IYUV:
p_pic->p[ Y_PLANE ].i_lines = i_height;
p_pic->p[ Y_PLANE ].i_pitch = i_width;
p_pic->p[ Y_PLANE ].i_visible_pitch = p_pic->p[ Y_PLANE ].i_pitch;
p_pic->p[ Y_PLANE ].i_pitch = i_width_aligned;
p_pic->p[ Y_PLANE ].i_visible_pitch = i_width;
p_pic->p[ U_PLANE ].i_lines = i_height / 2;
p_pic->p[ U_PLANE ].i_pitch = i_width / 2;
p_pic->p[ U_PLANE ].i_visible_pitch = p_pic->p[ U_PLANE ].i_pitch;
p_pic->p[ U_PLANE ].i_pitch = i_width_aligned / 2;
p_pic->p[ U_PLANE ].i_visible_pitch = i_width / 2;
p_pic->p[ V_PLANE ].i_lines = i_height / 2;
p_pic->p[ V_PLANE ].i_pitch = i_width / 2;
p_pic->p[ V_PLANE ].i_visible_pitch = p_pic->p[ V_PLANE ].i_pitch;
p_pic->p[ V_PLANE ].i_pitch = i_width_aligned / 2;
p_pic->p[ V_PLANE ].i_visible_pitch = i_width / 2;
p_pic->i_planes = 3;
break;
case FOURCC_I422:
p_pic->p[ Y_PLANE ].i_lines = i_height;
p_pic->p[ Y_PLANE ].i_pitch = i_width;
p_pic->p[ Y_PLANE ].i_visible_pitch = p_pic->p[ Y_PLANE ].i_pitch;
p_pic->p[ Y_PLANE ].i_pitch = i_width_aligned;
p_pic->p[ Y_PLANE ].i_visible_pitch = i_width;
p_pic->p[ U_PLANE ].i_lines = i_height;
p_pic->p[ U_PLANE ].i_pitch = i_width / 2;
p_pic->p[ U_PLANE ].i_visible_pitch = p_pic->p[ U_PLANE ].i_pitch;
p_pic->p[ U_PLANE ].i_pitch = i_width_aligned / 2;
p_pic->p[ U_PLANE ].i_visible_pitch = i_width / 2;
p_pic->p[ V_PLANE ].i_lines = i_height;
p_pic->p[ V_PLANE ].i_pitch = i_width / 2;
p_pic->p[ V_PLANE ].i_visible_pitch = p_pic->p[ V_PLANE ].i_pitch;
p_pic->p[ V_PLANE ].i_pitch = i_width_aligned / 2;
p_pic->p[ V_PLANE ].i_visible_pitch = i_width / 2;
p_pic->i_planes = 3;
break;
case FOURCC_I444:
p_pic->p[ Y_PLANE ].i_lines = i_height;
p_pic->p[ Y_PLANE ].i_pitch = i_width;
p_pic->p[ Y_PLANE ].i_visible_pitch = p_pic->p[ Y_PLANE ].i_pitch;
p_pic->p[ Y_PLANE ].i_pitch = i_width_aligned;
p_pic->p[ Y_PLANE ].i_visible_pitch = i_width;
p_pic->p[ U_PLANE ].i_lines = i_height;
p_pic->p[ U_PLANE ].i_pitch = i_width;
p_pic->p[ U_PLANE ].i_visible_pitch = p_pic->p[ U_PLANE ].i_pitch;
p_pic->p[ U_PLANE ].i_pitch = i_width_aligned;
p_pic->p[ U_PLANE ].i_visible_pitch = i_width;
p_pic->p[ V_PLANE ].i_lines = i_height;
p_pic->p[ V_PLANE ].i_pitch = i_width;
p_pic->p[ V_PLANE ].i_visible_pitch = p_pic->p[ V_PLANE ].i_pitch;
p_pic->p[ V_PLANE ].i_pitch = i_width_aligned;
p_pic->p[ V_PLANE ].i_visible_pitch = i_width;
p_pic->i_planes = 3;
break;
case FOURCC_YUVA:
p_pic->p[ Y_PLANE ].i_lines = i_height;
p_pic->p[ Y_PLANE ].i_pitch = i_width;
p_pic->p[ Y_PLANE ].i_visible_pitch = p_pic->p[ Y_PLANE ].i_pitch;
p_pic->p[ Y_PLANE ].i_pitch = i_width_aligned;
p_pic->p[ Y_PLANE ].i_visible_pitch = i_width;
p_pic->p[ U_PLANE ].i_lines = i_height;
p_pic->p[ U_PLANE ].i_pitch = i_width;
p_pic->p[ U_PLANE ].i_visible_pitch = p_pic->p[ U_PLANE ].i_pitch;
p_pic->p[ U_PLANE ].i_pitch = i_width_aligned;
p_pic->p[ U_PLANE ].i_visible_pitch = i_width;
p_pic->p[ V_PLANE ].i_lines = i_height;
p_pic->p[ V_PLANE ].i_pitch = i_width;
p_pic->p[ V_PLANE ].i_visible_pitch = p_pic->p[ V_PLANE ].i_pitch;
p_pic->p[ V_PLANE ].i_pitch = i_width_aligned;
p_pic->p[ V_PLANE ].i_visible_pitch = i_width;
p_pic->p[ A_PLANE ].i_lines = i_height;
p_pic->p[ A_PLANE ].i_pitch = i_width;
p_pic->p[ A_PLANE ].i_visible_pitch = p_pic->p[ A_PLANE ].i_pitch;
p_pic->p[ A_PLANE ].i_pitch = i_width_aligned;
p_pic->p[ A_PLANE ].i_visible_pitch = i_width;
p_pic->i_planes = 4;
break;
case FOURCC_YUVP:
p_pic->p->i_lines = i_height;
p_pic->p->i_pitch = i_width;
p_pic->p->i_visible_pitch = p_pic->p->i_pitch;
p_pic->p->i_pitch = i_width_aligned;
p_pic->p->i_visible_pitch = i_width;
p_pic->p->i_pixel_pitch = 8;
p_pic->i_planes = 1;
break;
case FOURCC_Y211:
p_pic->p->i_lines = i_height;
p_pic->p->i_pitch = i_width;
p_pic->p->i_visible_pitch = p_pic->p->i_pitch;
p_pic->p->i_pitch = i_width_aligned;
p_pic->p->i_visible_pitch = i_width;
p_pic->p->i_pixel_pitch = 4;
p_pic->i_planes = 1;
break;
......@@ -743,41 +756,33 @@ void vout_InitPicture( vlc_object_t *p_this, picture_t *p_pic,
case FOURCC_UYVY:
case FOURCC_YUY2:
p_pic->p->i_lines = i_height;
p_pic->p->i_pitch = i_width * 2;
p_pic->p->i_visible_pitch = p_pic->p->i_pitch;
p_pic->p->i_pitch = i_width_aligned * 2;
p_pic->p->i_visible_pitch = i_width * 2;
p_pic->p->i_pixel_pitch = 4;
p_pic->i_planes = 1;
break;
case FOURCC_RGB2:
p_pic->p->i_lines = i_height;
p_pic->p->i_pitch = i_width;
p_pic->p->i_visible_pitch = p_pic->p->i_pitch;
p_pic->p->i_pitch = i_width_aligned;
p_pic->p->i_visible_pitch = i_width;
p_pic->p->i_pixel_pitch = 1;
p_pic->i_planes = 1;
break;
case FOURCC_RV15:
p_pic->p->i_lines = i_height;
p_pic->p->i_pitch = i_width * 2;
p_pic->p->i_visible_pitch = p_pic->p->i_pitch;
p_pic->p->i_pitch = i_width_aligned * 2;
p_pic->p->i_visible_pitch = i_width * 2;
p_pic->p->i_pixel_pitch = 2;
/* FIXME: p_heap isn't always reachable
p_pic->p_heap->i_rmask = 0x001f;
p_pic->p_heap->i_gmask = 0x03e0;
p_pic->p_heap->i_bmask = 0x7c00; */
p_pic->i_planes = 1;
break;
case FOURCC_RV16:
p_pic->p->i_lines = i_height;
p_pic->p->i_pitch = i_width * 2;
p_pic->p->i_visible_pitch = p_pic->p->i_pitch;
p_pic->p->i_pitch = i_width_aligned * 2;
p_pic->p->i_visible_pitch = i_width * 2;
p_pic->p->i_pixel_pitch = 2;
/* FIXME: p_heap isn't always reachable
p_pic->p_heap->i_rmask = 0x001f;
p_pic->p_heap->i_gmask = 0x07e0;
p_pic->p_heap->i_bmask = 0xf800; */
p_pic->i_planes = 1;
break;
......@@ -787,29 +792,22 @@ void vout_InitPicture( vlc_object_t *p_this, picture_t *p_pic,
/* FIXME: Should be 3 here but x11 and our chroma conversion
* routines assume 4. */
#ifdef WIN32
p_pic->p->i_pitch = i_width * 3;
p_pic->p->i_pitch = i_width_aligned * 3;
p_pic->p->i_visible_pitch = i_width * 3;
p_pic->p->i_pixel_pitch = 3;
#else
p_pic->p->i_pitch = i_width * 4;
p_pic->p->i_pitch = i_width_aligned * 4;
p_pic->p->i_visible_pitch = i_width * 4;
p_pic->p->i_pixel_pitch = 4;
#endif
p_pic->p->i_visible_pitch = p_pic->p->i_pitch;
/* FIXME: p_heap isn't always reachable
p_pic->p_heap->i_rmask = 0xff0000;
p_pic->p_heap->i_gmask = 0x00ff00;
p_pic->p_heap->i_bmask = 0x0000ff; */
p_pic->i_planes = 1;
break;
case FOURCC_RV32:
p_pic->p->i_lines = i_height;
p_pic->p->i_pitch = i_width * 4;
p_pic->p->i_visible_pitch = p_pic->p->i_pitch;
p_pic->p->i_pitch = i_width_aligned * 4;
p_pic->p->i_visible_pitch = i_width * 4;
p_pic->p->i_pixel_pitch = 4;
/* FIXME: p_heap isn't always reachable
p_pic->p_heap->i_rmask = 0xff0000;
p_pic->p_heap->i_gmask = 0x00ff00;
p_pic->p_heap->i_bmask = 0x0000ff; */
p_pic->i_planes = 1;
break;
......
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