#include "input.h"
#define FAIL_IF_ERROR( cond, ... ) FAIL_IF_ERR( cond, "lavf", __VA_ARGS__ )
#undef DECLARE_ALIGNED
#include <libavformat/avformat.h>
#include <libavutil/mem.h>
#include <libavutil/pixdesc.h>
#include <libavutil/dict.h>
typedef struct
{
AVFormatContext *lavf;
AVFrame *frame;
int stream_id;
int next_frame;
int vfr_input;
cli_pic_t *first_pic;
} lavf_hnd_t;
static int handle_jpeg( int csp, int *fullrange )
{
switch( csp )
{
case AV_PIX_FMT_YUVJ420P: *fullrange = 1; return AV_PIX_FMT_YUV420P;
case AV_PIX_FMT_YUVJ422P: *fullrange = 1; return AV_PIX_FMT_YUV422P;
case AV_PIX_FMT_YUVJ444P: *fullrange = 1; return AV_PIX_FMT_YUV444P;
default: return csp;
}
}
static int read_frame_internal( cli_pic_t *p_pic, lavf_hnd_t *h, int i_frame, video_info_t *info )
{
if( h->first_pic && !info )
{
if( !i_frame )
{
XCHG( cli_image_t, p_pic->img, h->first_pic->img );
p_pic->pts = h->first_pic->pts;
}
lavf_input.picture_clean( h->first_pic, h );
free( h->first_pic );
h->first_pic = NULL;
if( !i_frame )
return 0;
}
AVCodecContext *c = h->lavf->streams[h->stream_id]->codec;
AVPacket pkt;
av_init_packet( &pkt );
pkt.data = NULL;
pkt.size = 0;
while( i_frame >= h->next_frame )
{
int finished = 0;
int ret = 0;
do
{
ret = av_read_frame( h->lavf, &pkt );
if( ret < 0 )
{
av_init_packet( &pkt );
pkt.data = NULL;
pkt.size = 0;
}
if( ret < 0 || pkt.stream_index == h->stream_id )
{
if( avcodec_decode_video2( c, h->frame, &finished, &pkt ) < 0 )
x264_cli_log( "lavf", X264_LOG_WARNING, "video decoding failed on frame %d\n", h->next_frame );
}
if( ret >= 0 )
av_free_packet( &pkt );
} while( !finished && ret >= 0 );
if( !finished )
return -1;
h->next_frame++;
}
memcpy( p_pic->img.stride, h->frame->linesize, sizeof(p_pic->img.stride) );
memcpy( p_pic->img.plane, h->frame->data, sizeof(p_pic->img.plane) );
int is_fullrange = 0;
p_pic->img.width = c->width;
p_pic->img.height = c->height;
p_pic->img.csp = handle_jpeg( c->pix_fmt, &is_fullrange ) | X264_CSP_OTHER;
if( info )
{
info->fullrange = is_fullrange;
info->interlaced = h->frame->interlaced_frame;
info->tff = h->frame->top_field_first;
}
if( h->vfr_input )
{
p_pic->pts = p_pic->duration = 0;
if( h->frame->pkt_pts != AV_NOPTS_VALUE )
p_pic->pts = h->frame->pkt_pts;
else if( h->frame->pkt_dts != AV_NOPTS_VALUE )
p_pic->pts = h->frame->pkt_dts;
else if( info )
{
h->vfr_input = info->vfr = 0;
return 0;
}
}
return 0;
}
static int open_file( char *psz_filename, hnd_t *p_handle, video_info_t *info, cli_input_opt_t *opt )
{
lavf_hnd_t *h = calloc( 1, sizeof(lavf_hnd_t) );
if( !h )
return -1;
av_register_all();
if( !strcmp( psz_filename, "-" ) )
psz_filename = "pipe:";
h->frame = av_frame_alloc();
if( !h->frame )
return -1;
AVDictionary *options = NULL;
if( opt->resolution )
{
av_dict_set( &options, "video_size", opt->resolution, 0 );
const char *csp = opt->colorspace ? opt->colorspace : av_get_pix_fmt_name( AV_PIX_FMT_YUV420P );
av_dict_set( &options, "pixel_format", csp, 0 );
}
AVInputFormat *format = NULL;
if( opt->format )
FAIL_IF_ERROR( !(format = av_find_input_format( opt->format )), "unknown file format: %s\n", opt->format );
FAIL_IF_ERROR( avformat_open_input( &h->lavf, psz_filename, format, &options ), "could not open input file\n" )
if( options )
av_dict_free( &options );
FAIL_IF_ERROR( avformat_find_stream_info( h->lavf, NULL ) < 0, "could not find input stream info\n" )
int i = 0;
while( i < h->lavf->nb_streams && h->lavf->streams[i]->codec->codec_type != AVMEDIA_TYPE_VIDEO )
i++;
FAIL_IF_ERROR( i == h->lavf->nb_streams, "could not find video stream\n" )
h->stream_id = i;
h->next_frame = 0;
AVCodecContext *c = h->lavf->streams[i]->codec;
info->fps_num = h->lavf->streams[i]->avg_frame_rate.num;
info->fps_den = h->lavf->streams[i]->avg_frame_rate.den;
info->timebase_num = h->lavf->streams[i]->time_base.num;
info->timebase_den = h->lavf->streams[i]->time_base.den;
info->thread_safe = 0;
h->vfr_input = info->vfr;
FAIL_IF_ERROR( avcodec_open2( c, avcodec_find_decoder( c->codec_id ), NULL ),
"could not find decoder for video stream\n" )
h->first_pic = malloc( sizeof(cli_pic_t) );
FAIL_IF_ERROR( !h->first_pic || lavf_input.picture_alloc( h->first_pic, h, X264_CSP_OTHER, info->width, info->height ),
"malloc failed\n" )
else if( read_frame_internal( h->first_pic, h, 0, info ) )
return -1;
info->width = c->width;
info->height = c->height;
info->csp = h->first_pic->img.csp;
info->num_frames = h->lavf->streams[i]->nb_frames;
info->sar_height = c->sample_aspect_ratio.den;
info->sar_width = c->sample_aspect_ratio.num;
info->fullrange |= c->color_range == AVCOL_RANGE_JPEG;
if( !strcasecmp( get_filename_extension( psz_filename ), "avs" ) &&
(c->pix_fmt == AV_PIX_FMT_BGRA || c->pix_fmt == AV_PIX_FMT_BGR24) )
info->csp |= X264_CSP_VFLIP;
*p_handle = h;
return 0;
}
static int picture_alloc( cli_pic_t *pic, hnd_t handle, int csp, int width, int height )
{
if( x264_cli_pic_alloc( pic, X264_CSP_NONE, width, height ) )
return -1;
pic->img.csp = csp;
pic->img.planes = 4;
return 0;
}
static int read_frame( cli_pic_t *pic, hnd_t handle, int i_frame )
{
return read_frame_internal( pic, handle, i_frame, NULL );
}
static void picture_clean( cli_pic_t *pic, hnd_t handle )
{
memset( pic, 0, sizeof(cli_pic_t) );
}
static int close_file( hnd_t handle )
{
lavf_hnd_t *h = handle;
avcodec_close( h->lavf->streams[h->stream_id]->codec );
avformat_close_input( &h->lavf );
av_frame_free( &h->frame );
free( h );
return 0;
}
const cli_input_t lavf_input = { open_file, picture_alloc, read_frame, NULL, picture_clean, close_file };