if( ret >= 0 )
reading = 1;
else
- eprintf("FFStream::decode_activate: open decoder failed\n");
+ eprintf(_("open decoder failed\n"));
}
else
- eprintf("FFStream::decode_activate: can't clone input file\n");
+ eprintf(_("can't clone input file\n"));
av_dict_free(&copts);
ff_unlock();
}
frame, AV_BUFFERSRC_FLAG_KEEP_REF);
if( ret < 0 ) {
av_frame_unref(frame);
- eprintf("FFStream::load_filter: av_buffersrc_add_frame_flags failed\n");
+ eprintf(_("av_buffersrc_add_frame_flags failed\n"));
}
return ret;
}
int FFStream::flush()
{
+ if( writing < 0 )
+ return -1;
int ret = 0;
while( ret >= 0 ) {
FFPacket pkt;
{
samples = *(float **)data;
if( resample_context ) {
- if( len > aud_bfr_sz ) {
+ if( len > aud_bfr_sz ) {
delete [] aud_bfr;
aud_bfr = 0;
}
ret = read_frame(frame);
if( ret > 0 ) ++curr_pos;
}
+ if( frame->format == AV_PIX_FMT_NONE || frame->width <= 0 || frame->height <= 0 )
+ ret = -1;
if( ret >= 0 ) {
- AVCodecContext *ctx = st->codec;
- ret = convert_cmodel(vframe, frame,
- ctx->pix_fmt, ctx->width, ctx->height);
+ ret = convert_cmodel(vframe, frame);
}
ret = ret > 0 ? 1 : ret < 0 ? -1 : 0;
return ret;
if( ret >= 0 ) {
AVFrame *frame = *picture;
frame->pts = curr_pos;
- AVCodecContext *ctx = st->codec;
- ret = convert_pixfmt(vframe, frame,
- ctx->pix_fmt, ctx->width, ctx->height);
+ ret = convert_pixfmt(vframe, frame);
}
if( ret >= 0 ) {
picture->queue(curr_pos);
AVPixelFormat FFVideoConvert::color_model_to_pix_fmt(int color_model)
{
- switch( color_model ) {
+ switch( color_model ) {
case BC_YUV422: return AV_PIX_FMT_YUYV422;
case BC_RGB888: return AV_PIX_FMT_RGB24;
case BC_RGBA8888: return AV_PIX_FMT_RGBA;
case BC_RGB565: return AV_PIX_FMT_RGB565;
case BC_RGB161616: return AV_PIX_FMT_RGB48LE;
case BC_RGBA16161616: return AV_PIX_FMT_RGBA64LE;
+ case BC_AYUV16161616: return AV_PIX_FMT_AYUV64LE;
default: break;
}
int FFVideoConvert::pix_fmt_to_color_model(AVPixelFormat pix_fmt)
{
- switch (pix_fmt) {
+ switch (pix_fmt) {
case AV_PIX_FMT_YUYV422: return BC_YUV422;
case AV_PIX_FMT_RGB24: return BC_RGB888;
case AV_PIX_FMT_RGBA: return BC_RGBA8888;
case AV_PIX_FMT_RGB565: return BC_RGB565;
case AV_PIX_FMT_RGB48LE: return BC_RGB161616;
case AV_PIX_FMT_RGBA64LE: return BC_RGBA16161616;
+ case AV_PIX_FMT_AYUV64LE: return BC_AYUV16161616;
default: break;
}
return -1;
}
-int FFVideoConvert::convert_picture_vframe(VFrame *frame,
- AVFrame *ip, AVPixelFormat ifmt, int iw, int ih)
+int FFVideoConvert::convert_picture_vframe(VFrame *frame, AVFrame *ip)
+{
+ AVFrame *ipic = av_frame_alloc();
+ int ret = convert_picture_vframe(frame, ip, ipic);
+ av_frame_free(&ipic);
+ return ret;
+}
+
+int FFVideoConvert::convert_picture_vframe(VFrame *frame, AVFrame *ip, AVFrame *ipic)
{
- // try bc_xfer methods
- int imodel = pix_fmt_to_color_model(ifmt);
- if( imodel >= 0 ) {
- long y_ofs = 0, u_ofs = 0, v_ofs = 0;
- uint8_t *data = ip->data[0];
- if( BC_CModels::is_yuv(imodel) ) {
- u_ofs = ip->data[1] - data;
- v_ofs = ip->data[2] - data;
- }
- VFrame iframe(data, -1, y_ofs, u_ofs, v_ofs, iw, ih, imodel, ip->linesize[0]);
- frame->transfer_from(&iframe);
- return 0;
- }
- // try sws methods
- AVFrame opic;
int cmodel = frame->get_color_model();
AVPixelFormat ofmt = color_model_to_pix_fmt(cmodel);
if( ofmt == AV_PIX_FMT_NB ) return -1;
- int size = av_image_fill_arrays(opic.data, opic.linesize,
+ int size = av_image_fill_arrays(ipic->data, ipic->linesize,
frame->get_data(), ofmt, frame->get_w(), frame->get_h(), 1);
if( size < 0 ) return -1;
- // transfer line sizes must match also
- int planar = BC_CModels::is_planar(cmodel);
- int packed_width = !planar ? frame->get_bytes_per_line() :
- BC_CModels::calculate_pixelsize(cmodel) * frame->get_w();
- if( packed_width != opic.linesize[0] ) return -1;
-
- if( planar ) {
+ int bpp = BC_CModels::calculate_pixelsize(cmodel);
+ int ysz = bpp * frame->get_w(), usz = ysz;
+ switch( cmodel ) {
+ case BC_YUV410P:
+ case BC_YUV411P:
+ usz /= 2;
+ case BC_YUV420P:
+ case BC_YUV422P:
+ usz /= 2;
+ case BC_YUV444P:
// override av_image_fill_arrays() for planar types
- opic.data[0] = frame->get_y();
- opic.data[1] = frame->get_u();
- opic.data[2] = frame->get_v();
- }
-
- convert_ctx = sws_getCachedContext(convert_ctx, iw, ih, ifmt,
- frame->get_w(), frame->get_h(), ofmt, SWS_BICUBIC, NULL, NULL, NULL);
+ ipic->data[0] = frame->get_y(); ipic->linesize[0] = ysz;
+ ipic->data[1] = frame->get_u(); ipic->linesize[1] = usz;
+ ipic->data[2] = frame->get_v(); ipic->linesize[2] = usz;
+ break;
+ default:
+ ipic->data[0] = frame->get_data();
+ ipic->linesize[0] = frame->get_bytes_per_line();
+ break;
+ }
+
+ AVPixelFormat pix_fmt = (AVPixelFormat)ip->format;
+ convert_ctx = sws_getCachedContext(convert_ctx, ip->width, ip->height, pix_fmt,
+ frame->get_w(), frame->get_h(), ofmt, SWS_POINT, NULL, NULL, NULL);
if( !convert_ctx ) {
fprintf(stderr, "FFVideoConvert::convert_picture_frame:"
" sws_getCachedContext() failed\n");
return -1;
}
- int ret = sws_scale(convert_ctx, ip->data, ip->linesize, 0, ih,
- opic.data, opic.linesize);
+ int ret = sws_scale(convert_ctx, ip->data, ip->linesize, 0, ip->height,
+ ipic->data, ipic->linesize);
if( ret < 0 ) {
ff_err(ret, "FFVideoConvert::convert_picture_frame: sws_scale() failed\n");
return -1;
return 0;
}
-int FFVideoConvert::convert_cmodel(VFrame *frame,
- AVFrame *ip, AVPixelFormat ifmt, int iw, int ih)
+int FFVideoConvert::convert_cmodel(VFrame *frame, AVFrame *ip)
{
// try direct transfer
- if( !convert_picture_vframe(frame, ip, ifmt, iw, ih) ) return 1;
+ if( !convert_picture_vframe(frame, ip) ) return 1;
// use indirect transfer
+ AVPixelFormat ifmt = (AVPixelFormat)ip->format;
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(ifmt);
int max_bits = 0;
for( int i = 0; i <desc->nb_components; ++i ) {
int bits = desc->comp[i].depth;
if( bits > max_bits ) max_bits = bits;
}
-// from libavcodec/pixdesc.c
-#define pixdesc_has_alpha(pixdesc) ((pixdesc)->nb_components == 2 || \
- (pixdesc)->nb_components == 4 || (pixdesc)->flags & AV_PIX_FMT_FLAG_PAL)
- int icolor_model = pixdesc_has_alpha(desc) ?
- (max_bits > 8 ? BC_RGBA16161616 : BC_RGBA8888) :
- (max_bits > 8 ? BC_RGB161616 : BC_RGB888) ;
- VFrame vframe(iw, ih, icolor_model);
- if( convert_picture_vframe(&vframe, ip, ifmt, iw, ih) ) return -1;
+ int imodel = pix_fmt_to_color_model(ifmt);
+ if( imodel < 0 ) {
+ int cmodel = frame->get_color_model();
+ BC_CModels::is_yuv(cmodel) ?
+ (BC_CModels::has_alpha(cmodel) ?
+ BC_AYUV16161616 :
+ (max_bits > 8 ? BC_AYUV16161616 : BC_YUV444P)) :
+ (BC_CModels::has_alpha(cmodel) ?
+ (max_bits > 8 ? BC_RGBA16161616 : BC_RGBA8888) :
+ (max_bits > 8 ? BC_RGB161616 : BC_RGB888)) ;
+ }
+ VFrame vframe(ip->width, ip->height, imodel);
+ if( convert_picture_vframe(&vframe, ip) ) return -1;
frame->transfer_from(&vframe);
return 1;
}
-int FFVideoConvert::transfer_cmodel(VFrame *frame,
- AVFrame *ifp, AVPixelFormat ifmt, int iw, int ih)
+int FFVideoConvert::transfer_cmodel(VFrame *frame, AVFrame *ifp)
{
- int ret = convert_cmodel(frame, ifp, ifmt, iw, ih);
+ int ret = convert_cmodel(frame, ifp);
if( ret > 0 ) {
const AVDictionary *src = av_frame_get_metadata(ifp);
AVDictionaryEntry *t = NULL;
return ret;
}
-int FFVideoConvert::convert_vframe_picture(VFrame *frame,
- AVFrame *op, AVPixelFormat ofmt, int ow, int oh)
+int FFVideoConvert::convert_vframe_picture(VFrame *frame, AVFrame *op)
+{
+ AVFrame *opic = av_frame_alloc();
+ int ret = convert_vframe_picture(frame, op, opic);
+ av_frame_free(&opic);
+ return ret;
+}
+
+int FFVideoConvert::convert_vframe_picture(VFrame *frame, AVFrame *op, AVFrame *opic)
{
- AVFrame opic;
int cmodel = frame->get_color_model();
AVPixelFormat ifmt = color_model_to_pix_fmt(cmodel);
if( ifmt == AV_PIX_FMT_NB ) return -1;
- int size = av_image_fill_arrays(opic.data, opic.linesize,
+ int size = av_image_fill_arrays(opic->data, opic->linesize,
frame->get_data(), ifmt, frame->get_w(), frame->get_h(), 1);
if( size < 0 ) return -1;
- // transfer line sizes must match also
- int planar = BC_CModels::is_planar(cmodel);
- int packed_width = !planar ? frame->get_bytes_per_line() :
- BC_CModels::calculate_pixelsize(cmodel) * frame->get_w();
- if( packed_width != opic.linesize[0] ) return -1;
-
- if( planar ) {
+ int bpp = BC_CModels::calculate_pixelsize(cmodel);
+ int ysz = bpp * frame->get_w(), usz = ysz;
+ switch( cmodel ) {
+ case BC_YUV410P:
+ case BC_YUV411P:
+ usz /= 2;
+ case BC_YUV420P:
+ case BC_YUV422P:
+ usz /= 2;
+ case BC_YUV444P:
// override av_image_fill_arrays() for planar types
- opic.data[0] = frame->get_y();
- opic.data[1] = frame->get_u();
- opic.data[2] = frame->get_v();
- }
-
- convert_ctx = sws_getCachedContext(convert_ctx, frame->get_w(), frame->get_h(), ifmt,
- ow, oh, ofmt, SWS_BICUBIC, NULL, NULL, NULL);
+ opic->data[0] = frame->get_y(); opic->linesize[0] = ysz;
+ opic->data[1] = frame->get_u(); opic->linesize[1] = usz;
+ opic->data[2] = frame->get_v(); opic->linesize[2] = usz;
+ break;
+ default:
+ opic->data[0] = frame->get_data();
+ opic->linesize[0] = frame->get_bytes_per_line();
+ break;
+ }
+
+ AVPixelFormat ofmt = (AVPixelFormat)op->format;
+ convert_ctx = sws_getCachedContext(convert_ctx, frame->get_w(), frame->get_h(),
+ ifmt, op->width, op->height, ofmt, SWS_POINT, NULL, NULL, NULL);
if( !convert_ctx ) {
fprintf(stderr, "FFVideoConvert::convert_frame_picture:"
" sws_getCachedContext() failed\n");
return -1;
}
- int ret = sws_scale(convert_ctx, opic.data, opic.linesize, 0, frame->get_h(),
+ int ret = sws_scale(convert_ctx, opic->data, opic->linesize, 0, frame->get_h(),
op->data, op->linesize);
if( ret < 0 ) {
ff_err(ret, "FFVideoConvert::convert_frame_picture: sws_scale() failed\n");
return 0;
}
-int FFVideoConvert::convert_pixfmt(VFrame *frame,
- AVFrame *op, AVPixelFormat ofmt, int ow, int oh)
+int FFVideoConvert::convert_pixfmt(VFrame *frame, AVFrame *op)
{
// try direct transfer
- if( !convert_vframe_picture(frame, op, ofmt, ow, oh) ) return 1;
+ if( !convert_vframe_picture(frame, op) ) return 1;
// use indirect transfer
- int colormodel = frame->get_color_model();
- int bits = BC_CModels::calculate_pixelsize(colormodel) * 8;
- bits /= BC_CModels::components(colormodel);
- int icolor_model = BC_CModels::has_alpha(colormodel) ?
- (bits > 8 ? BC_RGBA16161616 : BC_RGBA8888) :
- (bits > 8 ? BC_RGB161616: BC_RGB888) ;
- VFrame vframe(frame->get_w(), frame->get_h(), icolor_model);
+ int cmodel = frame->get_color_model();
+ int bits = BC_CModels::calculate_pixelsize(cmodel) * 8;
+ bits /= BC_CModels::components(cmodel);
+ AVPixelFormat ofmt = (AVPixelFormat)op->format;
+ int imodel = pix_fmt_to_color_model(ofmt);
+ if( imodel < 0 ) {
+ imodel =
+ BC_CModels::is_yuv(cmodel) ?
+ (BC_CModels::has_alpha(cmodel) ?
+ BC_AYUV16161616 :
+ (bits > 8 ? BC_AYUV16161616 : BC_YUV444P)) :
+ (BC_CModels::has_alpha(cmodel) ?
+ (bits > 8 ? BC_RGBA16161616 : BC_RGBA8888) :
+ (bits > 8 ? BC_RGB161616 : BC_RGB888)) ;
+ }
+ VFrame vframe(frame->get_w(), frame->get_h(), imodel);
vframe.transfer_from(frame);
- if( !convert_vframe_picture(&vframe, op, ofmt, ow, oh) ) return 1;
+ if( !convert_vframe_picture(&vframe, op) ) return 1;
return -1;
}
-int FFVideoConvert::transfer_pixfmt(VFrame *frame,
- AVFrame *ofp, AVPixelFormat ofmt, int ow, int oh)
+int FFVideoConvert::transfer_pixfmt(VFrame *frame, AVFrame *ofp)
{
- int ret = convert_pixfmt(frame, ofp, ofmt, ow, oh);
+ int ret = convert_pixfmt(frame, ofp);
if( ret > 0 ) {
BC_Hash *hp = frame->get_params();
AVDictionary **dict = avpriv_frame_get_metadatap(ofp);
{
FILE *fp = fopen(options,"r");
if( !fp ) {
- eprintf("FFMPEG::get_encoder: options open failed %s\n",options);
+ eprintf(_("options open failed %s\n"),options);
return 1;
}
if( get_encoder(fp, format, codec, bsfilter, bsargs) )
- eprintf(_("FFMPEG::get_encoder:"
- " err: format/codec not found %s\n"), options);
+ eprintf(_("format/codec not found %s\n"), options);
fclose(fp);
return 0;
}
if( line[0] == '\n' ) continue;
char key[BCSTRLEN], val[BCTEXTLEN];
if( scan_option_line(line, key, val) ) {
- eprintf(_("FFMPEG::read_options:"
- " err reading %s: line %d\n"), options, no);
+ eprintf(_("err reading %s: line %d\n"), options, no);
ret = 1;
}
if( !ret ) {
{
double base_time = time == AV_NOPTS_VALUE ? 0 :
av_rescale_q(time, time_base, AV_TIME_BASE_Q);
- return base_time / AV_TIME_BASE;
+ return base_time / AV_TIME_BASE;
}
int FFMPEG::info(char *text, int len)
{
struct stat st;
if( stat(fmt_ctx->filename, &st) < 0 ) {
- eprintf("FFMPEG::open_decoder: can't stat file: %s\n",
- fmt_ctx->filename);
+ eprintf(_("can't stat file: %s\n"), fmt_ctx->filename);
return 1;
}
printf("FFMPEG::open_decoder: some stream times estimated\n");
ff_lock("FFMPEG::open_decoder");
- int bad_time = 0;
- for( int i=0; i<(int)fmt_ctx->nb_streams; ++i ) {
+ int ret = 0, bad_time = 0;
+ for( int i=0; !ret && i<(int)fmt_ctx->nb_streams; ++i ) {
AVStream *st = fmt_ctx->streams[i];
if( st->duration == AV_NOPTS_VALUE ) bad_time = 1;
AVCodecContext *avctx = st->codec;
vid->nudge = st->start_time;
vid->reading = -1;
if( opt_video_filter )
- vid->create_filter(opt_video_filter, avctx,avctx);
+ ret = vid->create_filter(opt_video_filter, avctx,avctx);
}
else if( avctx->codec_type == AVMEDIA_TYPE_AUDIO ) {
if( avctx->channels < 1 ) continue;
aud->nudge = st->start_time;
aud->reading = -1;
if( opt_audio_filter )
- aud->create_filter(opt_audio_filter, avctx,avctx);
+ ret = aud->create_filter(opt_audio_filter, avctx,avctx);
}
}
if( bad_time )
printf("FFMPEG::open_decoder: some stream have bad times\n");
ff_unlock();
- return 0;
+ return ret < 0 ? -1 : 0;
}
int fd = ::open(filename,O_WRONLY);
if( fd < 0 ) fd = open(filename,O_WRONLY+O_CREAT,0666);
if( fd < 0 ) {
- eprintf("FFMPEG::init_encoder: bad file path: %s\n", filename);
+ eprintf(_("bad file path: %s\n"), filename);
return 1;
}
::close(fd);
int ret = get_file_format();
if( ret > 0 ) {
- eprintf("FFMPEG::init_encoder: bad file format: %s\n", filename);
+ eprintf(_("bad file format: %s\n"), filename);
return 1;
}
if( ret < 0 ) {
- eprintf("FFMPEG::init_encoder: mismatch audio/video file format: %s\n", filename);
+ eprintf(_("mismatch audio/video file format: %s\n"), filename);
return 1;
}
ff_lock("FFMPEG::init_encoder");
av_register_all();
avformat_alloc_output_context2(&fmt_ctx, 0, file_format, filename);
if( !fmt_ctx ) {
- eprintf("FFMPEG::init_encoder: failed: %s\n", filename);
+ eprintf(_("failed: %s\n"), filename);
ret = 1;
}
if( !ret ) {
char format_name[BCSTRLEN], codec_name[BCTEXTLEN];
char bsfilter[BCSTRLEN], bsargs[BCTEXTLEN];
if( get_encoder(option_path, format_name, codec_name, bsfilter, bsargs) ) {
- eprintf("FFMPEG::open_encoder: get_encoder failed %s:%s\n",
- option_path, filename);
+ eprintf(_("get_encoder failed %s:%s\n"), option_path, filename);
return 1;
}
const AVCodecDescriptor *codec_desc = 0;
AVCodec *codec = avcodec_find_encoder_by_name(codec_name);
if( !codec ) {
- eprintf("FFMPEG::open_encoder: cant find codec %s:%s\n",
- codec_name, filename);
+ eprintf(_("cant find codec %s:%s\n"), codec_name, filename);
ret = 1;
}
if( !ret ) {
codec_desc = avcodec_descriptor_get(codec->id);
if( !codec_desc ) {
- eprintf("FFMPEG::open_encoder: unknown codec %s:%s\n",
- codec_name, filename);
+ eprintf(_("unknown codec %s:%s\n"), codec_name, filename);
ret = 1;
}
}
if( !ret ) {
st = avformat_new_stream(fmt_ctx, 0);
if( !st ) {
- eprintf("FFMPEG::open_encoder: cant create stream %s:%s\n",
- codec_name, filename);
+ eprintf(_("cant create stream %s:%s\n"), codec_name, filename);
ret = 1;
}
- }
+ }
if( !ret ) {
AVCodecContext *ctx = st->codec;
switch( codec_desc->type ) {
case AVMEDIA_TYPE_AUDIO: {
if( has_audio ) {
- eprintf("FFMPEG::open_encoder: duplicate audio %s:%s\n",
- codec_name, filename);
+ eprintf(_("duplicate audio %s:%s\n"), codec_name, filename);
ret = 1;
break;
}
has_audio = 1;
if( scan_options(asset->ff_audio_options, sopts, st) ) {
- eprintf("FFMPEG::open_encoder: bad audio options %s:%s\n",
- codec_name, filename);
+ eprintf(_("bad audio options %s:%s\n"), codec_name, filename);
ret = 1;
break;
}
ctx->channel_layout = av_get_default_channel_layout(ctx->channels);
ctx->sample_rate = check_sample_rate(codec, asset->sample_rate);
if( !ctx->sample_rate ) {
- eprintf("FFMPEG::open_encoder:"
- " check_sample_rate failed %s\n", filename);
+ eprintf(_("check_sample_rate failed %s\n"), filename);
ret = 1;
break;
}
break; }
case AVMEDIA_TYPE_VIDEO: {
if( has_video ) {
- eprintf("FFMPEG::open_encoder: duplicate video %s:%s\n",
- codec_name, filename);
+ eprintf(_("duplicate video %s:%s\n"), codec_name, filename);
ret = 1;
break;
}
has_video = 1;
if( scan_options(asset->ff_video_options, sopts, st) ) {
- eprintf("FFMPEG::open_encoder: bad video options %s:%s\n",
- codec_name, filename);
+ eprintf(_("bad video options %s:%s\n"), codec_name, filename);
ret = 1;
break;
}
ctx->pix_fmt = codec->pix_fmts ? codec->pix_fmts[0] : AV_PIX_FMT_YUV420P;
AVRational frame_rate = check_frame_rate(codec, vid->frame_rate);
if( !frame_rate.num || !frame_rate.den ) {
- eprintf("FFMPEG::open_encoder:"
- " check_frame_rate failed %s\n", filename);
+ eprintf(_("check_frame_rate failed %s\n"), filename);
ret = 1;
break;
}
vid->writing = -1;
break; }
default:
- eprintf("FFMPEG::open_encoder: not audio/video, %s:%s\n",
- codec_name, filename);
+ eprintf(_("not audio/video, %s:%s\n"), codec_name, filename);
ret = 1;
}
}
ret = avcodec_open2(st->codec, codec, &sopts);
if( ret < 0 ) {
ff_err(ret,"FFMPEG::open_encoder");
- eprintf("FFMPEG::open_encoder: open failed %s:%s\n",
- codec_name, filename);
+ eprintf(_("open failed %s:%s\n"), codec_name, filename);
ret = 1;
}
else
fst->add_bsfilter(bsfilter, !bsargs[0] ? 0 : bsargs);
}
- ff_unlock();
if( !ret )
start_muxer();
+
+ ff_unlock();
av_dict_free(&sopts);
return ret;
}
(ret=avio_open(&fmt_ctx->pb, fmt_ctx->filename, AVIO_FLAG_WRITE)) < 0 ) {
ff_err(ret, "FFMPEG::encode_activate: err opening : %s\n",
fmt_ctx->filename);
- return 1;
+ return -1;
}
AVDictionary *fopts = 0;
if( ret < 0 ) {
ff_err(ret, "FFMPEG::encode_activate: write header failed %s\n",
fmt_ctx->filename);
- return 1;
+ return -1;
}
encoding = 1;
}
AVStream *st = ffaudio[stream]->st;
AVCodecID id = st->codec->codec_id;
const AVCodecDescriptor *desc = avcodec_descriptor_get(id);
- return desc ? desc->name : "Unknown";
+ return desc ? desc->name : _("Unknown");
}
int FFMPEG::ff_audio_pid(int stream)
AVStream *st = ffvideo[stream]->st;
AVCodecID id = st->codec->codec_id;
const AVCodecDescriptor *desc = avcodec_descriptor_get(id);
- return desc ? desc->name : "Unknown";
+ return desc ? desc->name : _("Unknown");
}
double FFMPEG::ff_frame_rate(int stream)
AVCodecContext *src_ctx, AVCodecContext *sink_ctx)
{
avfilter_register_all();
- AVFilter *filter = avfilter_get_by_name(filter_spec);
+ const char *sp = filter_spec;
+ char filter_name[BCSTRLEN], *np = filter_name;
+ int i = sizeof(filter_name);
+ while( --i>=0 && *sp!=0 && !strchr(" \t:=,",*sp) ) *np++ = *sp++;
+ *np = 0;
+ AVFilter *filter = !filter_name[0] ? 0 : avfilter_get_by_name(filter_name);
if( !filter || avfilter_pad_get_type(filter->inputs,0) != AVMEDIA_TYPE_VIDEO ) {
ff_err(AVERROR(EINVAL), "FFVideoStream::create_filter: %s\n", filter_spec);
return -1;
ff_err(ret, "FFVideoStream::create_filter");
else
ret = FFStream::create_filter(filter_spec);
- return ret >= 0 ? 0 : 1;
+ return ret >= 0 ? 0 : -1;
}
int FFAudioStream::create_filter(const char *filter_spec,
AVCodecContext *src_ctx, AVCodecContext *sink_ctx)
{
avfilter_register_all();
- AVFilter *filter = avfilter_get_by_name(filter_spec);
+ const char *sp = filter_spec;
+ char filter_name[BCSTRLEN], *np = filter_name;
+ int i = sizeof(filter_name);
+ while( --i>=0 && *sp!=0 && !strchr(" \t:=,",*sp) ) *np++ = *sp++;
+ *np = 0;
+ AVFilter *filter = !filter_name[0] ? 0 : avfilter_get_by_name(filter_name);
if( !filter || avfilter_pad_get_type(filter->inputs,0) != AVMEDIA_TYPE_AUDIO ) {
ff_err(AVERROR(EINVAL), "FFAudioStream::create_filter: %s\n", filter_spec);
return -1;
ff_err(ret, "FFAudioStream::create_filter");
else
ret = FFStream::create_filter(filter_spec);
- return ret >= 0 ? 0 : 1;
+ return ret >= 0 ? 0 : -1;
}
int FFStream::create_filter(const char *filter_spec)
if( ret >= 0 )
ret = avfilter_graph_config(filter_graph, NULL);
- if( ret < 0 )
+ if( ret < 0 ) {
ff_err(ret, "FFStream::create_filter");
+ avfilter_graph_free(&filter_graph);
+ filter_graph = 0;
+ }
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
return ret;
av_init_packet(&pkt);
AVFrame *frame = av_frame_alloc();
if( !frame ) {
- fprintf(stderr, "FFMPEG::scan: av_frame_alloc failed\n");
+ fprintf(stderr,"FFMPEG::scan: ");
+ fprintf(stderr,_("av_frame_alloc failed\n"));
return -1;
}
AVStream *st = fmt_ctx->streams[i];
AVCodecID codec_id = st->codec->codec_id;
AVCodec *decoder = avcodec_find_decoder(codec_id);
- if( avcodec_open2(st->codec, decoder, &copts) < 0 )
- fprintf(stderr, "FFMPEG::scan: codec open failed\n");
+ if( avcodec_open2(st->codec, decoder, &copts) < 0 ) {
+ fprintf(stderr,"FFMPEG::scan: ");
+ fprintf(stderr,_("codec open failed\n"));
+ }
av_dict_free(&copts);
}
int errs = 0;
if( ret < 0 ) {
if( ret == AVERROR_EOF ) break;
if( ++errs > 100 ) {
- ff_err(ret, "over 100 read_frame errs\n");
+ ff_err(ret,_("over 100 read_frame errs\n"));
break;
}
continue;
int64_t pos = index_state->pos(ch);
if( pos != aud->curr_pos ) {
if( abs(pos-aud->curr_pos) > 1 )
-printf("audio%d pad %ld %ld (%ld)\n", aud->idx, pos, aud->curr_pos, pos-aud->curr_pos);
+printf("audio%d pad %jd %jd (%jd)\n", aud->idx, pos, aud->curr_pos, pos-aud->curr_pos);
index_state->pad_data(ch, nch, aud->curr_pos);
}
av_frame_unref(frame);
projects / goodguy / history.git / blobdiff