+/*
+ * CINELERRA
+ * Copyright (C) 2012-2014 Paolo Rampino
+ *
+ * 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-1307 USA
+ *
+ */
#include <stdio.h>
#include <stdint.h>
#include "ffmpeg.h"
#include "indexfile.h"
#include "interlacemodes.h"
+#ifdef HAVE_DV
#include "libdv.h"
+#endif
#include "libmjpeg.h"
#include "mainerror.h"
#include "mwindow.h"
{
return AV_HWDEVICE_TYPE_NONE;
}
-
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+int FFStream::decode_hw_format(const AVCodec *decoder, AVHWDeviceType type)
+#else
int FFStream::decode_hw_format(AVCodec *decoder, AVHWDeviceType type)
+#endif
{
return 0;
}
}
while( ret >= 0 && st != 0 && !reading ) {
AVCodecID codec_id = st->codecpar->codec_id;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ const AVCodec *decoder = 0;
+#else
AVCodec *decoder = 0;
+#endif
if( is_video() ) {
if( ffmpeg->opt_video_decoder )
decoder = avcodec_find_decoder_by_name(ffmpeg->opt_video_decoder);
ret = av_interleaved_write_frame(ffmpeg->fmt_ctx, pkt);
}
else {
+ bsfc->time_base_in = st->time_base;
+ avcodec_parameters_copy(bsfc->par_in, st->codecpar);
+ av_bsf_init(bsfc);
+
ret = av_bsf_send_packet(bsfc, pkt);
while( ret >= 0 ) {
FFPacket bs;
if( ret == AVERROR_EOF ) return -1;
break;
}
+ //printf(" filter name %s \n", bsfc->filter[0].name);
+ //avcodec_parameters_copy(ffmpeg->fmt_ctx->streams[0]->codecpar, bsfc->par_out);
+ //avcodec_parameters_copy(st->codecpar, bsfc->par_out);
av_packet_rescale_ts(bs, avctx->time_base, st->time_base);
bs->stream_index = st->index;
ret = av_interleaved_write_frame(ffmpeg->fmt_ctx, bs);
ret = avcodec_send_frame(avctx, frame);
if( !ret && frame ) return pkts;
if( ret < 0 && ret != AVERROR(EAGAIN) ) break;
+ if ( ret == AVERROR(EAGAIN) && !frame ) continue;
FFPacket opkt;
ret = avcodec_receive_packet(avctx, opkt);
- if( !frame && ret == AVERROR_EOF ) return pkts;
- if( ret < 0 ) break;
+ if( !frame && (ret == AVERROR_EOF || ret == AVERROR(EAGAIN) )) return pkts;
+ //if( ret < 0 ) break;
ret = write_packet(opkt);
if( ret < 0 ) break;
++pkts;
double secs = pos < 0 ? 0. : pos / rate;
AVRational time_base = st->time_base;
int64_t tstmp = time_base.num > 0 ? secs * time_base.den/time_base.num : 0;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ int nb_index_entries = avformat_index_get_entries_count(st);
+#endif
if( !tstmp ) {
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ if( nb_index_entries > 0 ) tstmp = (avformat_index_get_entry(st, 0))->timestamp;
+#else
if( st->nb_index_entries > 0 ) tstmp = st->index_entries[0].timestamp;
+#endif
else if( st->start_time != AV_NOPTS_VALUE ) tstmp = st->start_time;
+#if LIBAVCODEC_VERSION_INT <= AV_VERSION_INT(58,134,100)
else if( st->first_dts != AV_NOPTS_VALUE ) tstmp = st->first_dts;
+#endif
else tstmp = INT64_MIN+1;
}
else if( nudge != AV_NOPTS_VALUE ) tstmp += nudge;
}
return type;
}
-
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+int FFVideoStream::decode_hw_format(const AVCodec *decoder, AVHWDeviceType type)
+#else
int FFVideoStream::decode_hw_format(AVCodec *decoder, AVHWDeviceType type)
+#endif
{
int ret = 0;
hw_pix_fmt = AV_PIX_FMT_NONE;
if( hw_pix_fmt >= 0 ) {
hw_pixfmt = hw_pix_fmt;
avctx->get_format = get_hw_format;
+ const char *drm_node = getenv("CIN_DRM_DEC");
+ if(drm_node && type==AV_HWDEVICE_TYPE_VAAPI) {
+ ret = av_hwdevice_ctx_create(&hw_device_ctx, type, drm_node, 0, 0);
+ }
+ else {
ret = av_hwdevice_ctx_create(&hw_device_ctx, type, 0, 0, 0);
+ }
+
if( ret >= 0 ) {
avctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
ret = 1;
AVHWDeviceType FFVideoStream::encode_hw_activate(const char *hw_dev)
{
+ const char *drm_node_enc = getenv("CIN_DRM_ENC");
AVBufferRef *hw_device_ctx = 0;
AVBufferRef *hw_frames_ref = 0;
AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
}
}
if( type != AV_HWDEVICE_TYPE_NONE ) {
- int ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI, 0, 0, 0);
+ int ret = 0;
+ if (drm_node_enc) {
+ ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI, drm_node_enc, 0, 0);
+ } else {
+ ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI, 0, 0, 0);
+ }
if( ret < 0 ) {
ff_err(ret, "Failed to create a HW device.\n");
type = AV_HWDEVICE_TYPE_NONE;
return -1;
}
- if (ffmpeg->interlace_from_codec)
- return 1;
+ if (ffmpeg->interlace_from_codec) return 1;
ret = read_frame(frame);
if( ret > 0 ) {
ret = -1;
ret = ret > 0 ? 1 : ret < 0 ? -1 : 0;
+ av_frame_free(&frame);
return ret;
}
}
int color_space = SWS_CS_ITU601;
switch( preferences->yuv_color_space ) {
- case BC_COLORS_BT601: color_space = SWS_CS_ITU601; break;
+ case BC_COLORS_BT601_PAL: color_space = SWS_CS_ITU601; break;
+ case BC_COLORS_BT601_NTSC: color_space = SWS_CS_SMPTE170M; break;
case BC_COLORS_BT709: color_space = SWS_CS_ITU709; break;
- case BC_COLORS_BT2020: color_space = SWS_CS_BT2020; break;
+ case BC_COLORS_BT2020_NCL:
+ case BC_COLORS_BT2020_CL: color_space = SWS_CS_BT2020; break;
}
const int *color_table = sws_getCoefficients(color_space);
}
int color_space = SWS_CS_ITU601;
switch( preferences->yuv_color_space ) {
- case BC_COLORS_BT601: color_space = SWS_CS_ITU601; break;
+ case BC_COLORS_BT601_PAL: color_space = SWS_CS_ITU601; break;
+ case BC_COLORS_BT601_NTSC: color_space = SWS_CS_SMPTE170M; break;
case BC_COLORS_BT709: color_space = SWS_CS_ITU709; break;
- case BC_COLORS_BT2020: color_space = SWS_CS_BT2020; break;
+ case BC_COLORS_BT2020_NCL:
+ case BC_COLORS_BT2020_CL: color_space = SWS_CS_BT2020; break;
}
const int *color_table = sws_getCoefficients(color_space);
delete [] opt_hw_dev;
}
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+int FFMPEG::check_sample_rate(const AVCodec *codec, int sample_rate)
+#else
int FFMPEG::check_sample_rate(AVCodec *codec, int sample_rate)
+#endif
{
const int *p = codec->supported_samplerates;
if( !p ) return sample_rate;
return 0;
}
+// check_frame_rate and std_frame_rate needed for 23.976
+// and 59.94 fps mpeg2
static inline AVRational std_frame_rate(int i)
{
static const int m1 = 1001*12, m2 = 1000*12;
static const int freqs[] = {
40*m1, 48*m1, 50*m1, 60*m1, 80*m1,120*m1, 240*m1,
- 24*m2, 30*m2, 60*m2, 12*m2, 15*m2, 48*m2, 0,
+ 24*m2, 30*m2, 60*m2, 12*m2, 15*m2, 48*m2, 90*m2,
+ 100*m2, 120*m2, 144*m2, 72*m2, 0,
};
int freq = i<30*12 ? (i+1)*1001 : freqs[i-30*12];
return (AVRational) { freq, 1001*12 };
cin_fmt = (int)av_get_sample_fmt(cin_sample_fmt);
if( cin_fmt < 0 ) {
char audio_codec[BCSTRLEN]; audio_codec[0] = 0;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,18,100)
+ const AVCodec *av_codec = !FFMPEG::get_codec(audio_codec, "audio", asset->acodec) ?
+#else
AVCodec *av_codec = !FFMPEG::get_codec(audio_codec, "audio", asset->acodec) ?
+#endif
avcodec_find_encoder_by_name(audio_codec) : 0;
if( av_codec && av_codec->sample_fmts )
cin_fmt = find_best_sample_fmt_of_list(av_codec->sample_fmts, AV_SAMPLE_FMT_FLT);
cin_fmt = (int)av_get_pix_fmt(cin_pix_fmt);
if( cin_fmt < 0 ) {
char video_codec[BCSTRLEN]; video_codec[0] = 0;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,18,100)
+ const AVCodec *av_codec = !get_codec(video_codec, "video", asset->vcodec) ?
+#else
AVCodec *av_codec = !get_codec(video_codec, "video", asset->vcodec) ?
+#endif
avcodec_find_encoder_by_name(video_codec) : 0;
if( av_codec && av_codec->pix_fmts ) {
if( 0 && edl ) { // frequently picks a bad answer
return 0;
}
-
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+int FFCodecRemaps::update(AVCodecID &codec_id, const AVCodec *&decoder)
+{
+ const AVCodec *codec = avcodec_find_decoder(codec_id);
+#else
int FFCodecRemaps::update(AVCodecID &codec_id, AVCodec *&decoder)
{
AVCodec *codec = avcodec_find_decoder(codec_id);
+#endif
if( !codec ) return -1;
const char *name = codec->name;
FFCodecRemaps &map = *this;
enum AVColorRange range = st->codecpar->color_range;
const char *rg = av_color_range_name(range);
report("/ range:%s\n", rg ? rg : unkn);
+
+ AVRational sar = av_guess_sample_aspect_ratio(fmt_ctx, st, NULL);
+ AVRational display_aspect_ratio;
+ if(sar.num) {
+
+ av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
+ st->codecpar->width * (int64_t)sar.num,
+ st->codecpar->height * (int64_t)sar.den,
+ 1024 * 1024);
+/* report(" Guessed SAR: %d:%d, ", sar.num, sar.den );
+ report("DAR: %d:%d \n", display_aspect_ratio.num, display_aspect_ratio.den); */
+ }
+ if (st->sample_aspect_ratio.num)
+ {
+ av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
+ st->codecpar->width * (int64_t)st->sample_aspect_ratio.num,
+ st->codecpar->height * (int64_t)st->sample_aspect_ratio.den,
+ 1024 * 1024);
+ report(" container Detected SAR: %d:%d , DAR %d:%d \n", st->sample_aspect_ratio.num, st->sample_aspect_ratio.den, display_aspect_ratio.num, display_aspect_ratio.den);
+ }
+ if (st->codecpar->sample_aspect_ratio.num)
+ {
+ av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
+ st->codecpar->width * (int64_t)st->codecpar->sample_aspect_ratio.num,
+ st->codecpar->height * (int64_t)st->codecpar->sample_aspect_ratio.den,
+ 1024 * 1024);
+ report(" codec Detected SAR: %d:%d , DAR %d:%d \n", st->codecpar->sample_aspect_ratio.num, st->codecpar->sample_aspect_ratio.den, display_aspect_ratio.num, display_aspect_ratio.den);
+ }
double secs = to_secs(st->duration, st->time_base);
int64_t length = secs * vid->frame_rate + 0.5;
double ofs = to_secs((vid->nudge - st->start_time), st->time_base);
char *sp = strrchr(bp, '.');
if( !sp ) sp = bp + strlen(bp);
FILE *fp = 0;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,18,100)
+ const AVInputFormat *ifmt = 0;
+#else
AVInputFormat *ifmt = 0;
+#endif
if( sp ) {
strcpy(sp, ".opts");
fp = fopen(file_opts, "r");
}
switch( avpar->color_space ) {
case AVCOL_SPC_BT470BG:
+ vid->color_space = BC_COLORS_BT601_PAL;
+ break;
case AVCOL_SPC_SMPTE170M:
- vid->color_space = BC_COLORS_BT601;
+ vid->color_space = BC_COLORS_BT601_NTSC;
break;
case AVCOL_SPC_BT709:
vid->color_space = BC_COLORS_BT709;
break;
case AVCOL_SPC_BT2020_NCL:
+ vid->color_space = BC_COLORS_BT2020_NCL;
+ break;
case AVCOL_SPC_BT2020_CL:
- vid->color_space = BC_COLORS_BT2020;
+ vid->color_space = BC_COLORS_BT2020_CL;
break;
default:
- vid->color_space = !file_base ? BC_COLORS_BT601 :
+ vid->color_space = !file_base ? BC_COLORS_BT601_NTSC :
file_base->file->preferences->yuv_color_space;
break;
}
AVCodecContext *ctx = 0;
const AVCodecDescriptor *codec_desc = 0;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ const AVCodec *codec = avcodec_find_encoder_by_name(codec_name);
+#else
AVCodec *codec = avcodec_find_encoder_by_name(codec_name);
+#endif
if( !codec ) {
eprintf(_("cant find codec %s:%s\n"), codec_name, filename);
ret = 1;
vid->width = asset->width;
vid->height = asset->height;
vid->frame_rate = asset->frame_rate;
+#if 0
+ char tc_str[20] = "00:00:00:00";
+ double tc_offset;
+ if(asset->timecode > 0)
+ Units::totext(tc_str, asset->timecode, TIME_HMSF, 0, asset->frame_rate, 0);
+ //printf("tc: %s \n", tc_str);
+ av_dict_set(&st->metadata, "timecode", tc_str, 0);
+#endif
if( (vid->color_range = asset->ff_color_range) < 0 )
vid->color_range = file_base->file->preferences->yuv_color_range;
switch( vid->color_range ) {
if( (vid->color_space = asset->ff_color_space) < 0 )
vid->color_space = file_base->file->preferences->yuv_color_space;
switch( vid->color_space ) {
- case BC_COLORS_BT601: ctx->colorspace = AVCOL_SPC_SMPTE170M; break;
+ case BC_COLORS_BT601_NTSC: ctx->colorspace = AVCOL_SPC_SMPTE170M; break;
+ case BC_COLORS_BT601_PAL: ctx->colorspace = AVCOL_SPC_BT470BG; break;
case BC_COLORS_BT709: ctx->colorspace = AVCOL_SPC_BT709; break;
- case BC_COLORS_BT2020: ctx->colorspace = AVCOL_SPC_BT2020_NCL; break;
+ case BC_COLORS_BT2020_NCL: ctx->colorspace = AVCOL_SPC_BT2020_NCL; break;
+ case BC_COLORS_BT2020_CL: ctx->colorspace = AVCOL_SPC_BT2020_CL; break;
}
AVPixelFormat pix_fmt = av_get_pix_fmt(asset->ff_pixel_format);
if( opt_hw_dev != 0 ) {
int mask_h = (1<<desc->log2_chroma_h)-1;
ctx->height = (vid->height+mask_h) & ~mask_h;
ctx->sample_aspect_ratio = to_sample_aspect_ratio(asset);
- AVRational frame_rate = check_frame_rate(codec->supported_framerates, vid->frame_rate);
+ AVRational frame_rate;
+ if (ctx->codec->id == AV_CODEC_ID_MPEG1VIDEO ||
+ ctx->codec->id == AV_CODEC_ID_MPEG2VIDEO)
+ frame_rate = check_frame_rate(codec->supported_framerates, vid->frame_rate);
+ else
+ frame_rate = av_d2q(vid->frame_rate, INT_MAX);
if( !frame_rate.num || !frame_rate.den ) {
eprintf(_("check_frame_rate failed %s\n"), filename);
ret = 1;
frame_rate.num, frame_rate.den, INT_MAX);
ctx->framerate = (AVRational) { frame_rate.num, frame_rate.den };
ctx->time_base = (AVRational) { frame_rate.den, frame_rate.num };
+ if(!strcmp(format_name, "webm") || !strcmp(format_name, "matroska") || !strcmp(format_name, "mov") ||
+ !strcmp(format_name, "qt") || !strcmp(format_name, "mp4") || !strcmp(format_name, "avi") ||
+ !strcmp(format_name, "dv") || !strcmp(format_name, "yuv4mpegpipe"))
+ {
+ if (to_sample_aspect_ratio(asset).den > 0)
+ st->sample_aspect_ratio = to_sample_aspect_ratio(asset);
+ }
st->avg_frame_rate = frame_rate;
st->time_base = ctx->time_base;
vid->writing = -1;
}
if( ret >= 0 ) {
_Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#if LIBAVCODEC_VERSION_INT <= AV_VERSION_INT(58,134,100)
ret = avcodec_copy_context(st->codec, ctx);
+#else
+ ret = avcodec_parameters_to_context(ctx, st->codecpar);
+#endif
_Pragma("GCC diagnostic warning \"-Wdeprecated-declarations\"")
if( ret < 0 )
fprintf(stderr, "Could not copy the stream context\n");
AVCodecParameters *par = ffvideo[stream]->st->codecpar;
AVRational dar;
AVRational sar = av_guess_sample_aspect_ratio(fmt_ctx, strm, NULL);
- if (sar.num) {
- printf("sample_aspect_ratio, %f \n", av_q2d(sar));
+ if (sar.num && ffvideo[stream]->get_rotation_angle() == 0) {
av_reduce(&dar.num, &dar.den,
par->width * sar.num,
par->height * sar.den,
1024*1024);
- printf("display_aspect_ratio, %f \n", av_q2d(dar));
return av_q2d(dar);
}
return ffvideo[stream]->aspect_ratio;
// https://ffmpeg.org/doxygen/trunk/structAVCodecParserContext.html
/* reads from demuxer because codec frame not ready */
int interlace0 = ffvideo[stream]->st->codecpar->field_order;
- printf("interlace from demux: %i\n", interlace0);
switch (interlace0)
{
double FFVideoStream::get_rotation_angle()
{
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ size_t size = 0;
+#else
int size = 0;
+#endif
int *matrix = (int*)av_stream_get_side_data(st, AV_PKT_DATA_DISPLAYMATRIX, &size);
int len = size/sizeof(*matrix);
if( !matrix || len < 5 ) return 0;
AVDictionary *copts = 0;
av_dict_copy(&copts, opts, 0);
AVCodecID codec_id = st->codecpar->codec_id;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ const AVCodec *decoder = 0;
+#else
AVCodec *decoder = 0;
+#endif
switch( st->codecpar->codec_type ) {
case AVMEDIA_TYPE_VIDEO:
if( opt_video_decoder )
int in = 0;
int64_t sz = marks.size();
int max_entries = fmt_ctx->max_index_size / sizeof(AVIndexEntry) - 1;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ int nb_ent = avformat_index_get_entries_count(st);
+#endif
+#if LIBAVCODEC_VERSION_INT <= AV_VERSION_INT(58,134,100)
int nb_ent = st->nb_index_entries;
+#endif
// some formats already have an index
if( nb_ent > 0 ) {
+#if LIBAVCODEC_VERSION_INT <= AV_VERSION_INT(58,134,100)
AVIndexEntry *ep = &st->index_entries[nb_ent-1];
+#endif
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ const AVIndexEntry *ep = avformat_index_get_entry(st, nb_ent-1);
+#endif
int64_t tstmp = ep->timestamp;
if( nudge != AV_NOPTS_VALUE ) tstmp -= nudge;
double secs = ffmpeg->to_secs(tstmp, st->time_base);
projects / goodguy / cinelerra.git / blobdiff