X-Git-Url: https://git.cinelerra-gg.org/git/?p=goodguy%2Fcinelerra.git;a=blobdiff_plain;f=cinelerra-5.1%2Fcinelerra%2Fffmpeg.C;h=8b9cc27fe5585d70fa522c8a7cd580c47a243331;hp=9569de77efcd11c0979e0c2f6d93c4adf1c2cb86;hb=86c9537e0540010ff43b16feb4cd7de98409eba1;hpb=9c8644d5f3f05b52a81c259c32217bcd57792ae5

diff --git a/cinelerra-5.1/cinelerra/ffmpeg.C b/cinelerra-5.1/cinelerra/ffmpeg.C
index 9569de77..8b9cc27f 100644
--- a/cinelerra-5.1/cinelerra/ffmpeg.C
+++ b/cinelerra-5.1/cinelerra/ffmpeg.C
@@ -333,12 +333,35 @@ int FFStream::encode_activate()
 	return writing;
 }
 
+// this is a global parameter that really should be in the context
 static AVPixelFormat hw_pix_fmt = AV_PIX_FMT_NONE; // protected by ff_lock
+
+// goofy maneuver to attach a hw_format to an av_context
+#define GET_HW_PIXFMT(fn, fmt) \
+static AVPixelFormat get_hw_##fn(AVCodecContext *ctx, const enum AVPixelFormat *pix_fmts) { \
+	return fmt; \
+}
+GET_HW_PIXFMT(vaapi, AV_PIX_FMT_VAAPI)
+GET_HW_PIXFMT(vdpau, AV_PIX_FMT_VDPAU)
+GET_HW_PIXFMT(cuda,  AV_PIX_FMT_CUDA)
+GET_HW_PIXFMT(nv12,  AV_PIX_FMT_NV12)
+
 static enum AVPixelFormat get_hw_format(AVCodecContext *ctx,
 			const enum AVPixelFormat *pix_fmts)
 {
-	for( const enum AVPixelFormat *p=pix_fmts; *p!=AV_PIX_FMT_NONE; ++p )
-		if( *p == hw_pix_fmt ) return *p;
+	for( const enum AVPixelFormat *p=pix_fmts; *p!=AV_PIX_FMT_NONE; ++p ) {
+		if( *p != hw_pix_fmt ) continue;
+		switch( *p ) {
+		case AV_PIX_FMT_VAAPI: ctx->get_format = get_hw_vaapi; return *p;
+		case AV_PIX_FMT_VDPAU: ctx->get_format = get_hw_vdpau; return *p;
+		case AV_PIX_FMT_CUDA:  ctx->get_format = get_hw_cuda;  return *p;
+		case AV_PIX_FMT_NV12:  ctx->get_format = get_hw_nv12;  return *p;
+		default:
+			fprintf(stderr, "Unknown HW surface format: %s\n",
+				av_get_pix_fmt_name(*p));
+			continue;
+		}
+	}
 	fprintf(stderr, "Failed to get HW surface format.\n");
 	return hw_pix_fmt = AV_PIX_FMT_NONE;
 }
@@ -374,7 +397,21 @@ int FFStream::decode_activate()
 		}
 		while( ret >= 0 && st != 0 && !reading ) {
 			AVCodecID codec_id = st->codecpar->codec_id;
-			AVCodec *decoder = avcodec_find_decoder(codec_id);
+			AVCodec *decoder = 0;
+			if( is_video() ) {
+				if( ffmpeg->opt_video_decoder )
+					decoder = avcodec_find_decoder_by_name(ffmpeg->opt_video_decoder);
+				else
+					ffmpeg->video_codec_remaps.update(codec_id, decoder);
+			}
+			else if( is_audio() ) {
+				if( ffmpeg->opt_audio_decoder )
+					decoder = avcodec_find_decoder_by_name(ffmpeg->opt_audio_decoder);
+				else
+					ffmpeg->audio_codec_remaps.update(codec_id, decoder);
+			}
+			if( !decoder )
+				decoder = avcodec_find_decoder(codec_id);
 			avctx = avcodec_alloc_context3(decoder);
 			if( !avctx ) {
 				eprintf(_("cant allocate codec context\n"));
@@ -455,7 +492,7 @@ int FFStream::decode(AVFrame *frame)
 			AVPacket *pkt = ret > 0 ? (AVPacket*)ipkt : 0;
 			if( pkt ) {
 				if( pkt->stream_index != st->index ) continue;
-				if( !pkt->data | !pkt->size ) continue;
+				if( !pkt->data || !pkt->size ) continue;
 			}
 			if( (ret=avcodec_send_packet(avctx, pkt)) < 0 ) {
 				ff_err(ret, "FFStream::decode: avcodec_send_packet failed.\nfile:%s\n",
@@ -835,7 +872,8 @@ int FFAudioStream::decode_frame(AVFrame *frame)
 	frame->best_effort_timestamp = AV_NOPTS_VALUE;
 	int ret = avcodec_receive_frame(avctx, frame);
 	if( ret < 0 ) {
-		if( first_frame || ret == AVERROR(EAGAIN) ) return 0;
+		if( first_frame ) return 0;
+		if( ret == AVERROR(EAGAIN) ) return 0;
 		if( ret == AVERROR_EOF ) { st_eof(1); return 0; }
 		ff_err(ret, "FFAudioStream::decode_frame: Could not read audio frame.\nfile:%s\n",
 				ffmpeg->fmt_ctx->url);
@@ -995,7 +1033,8 @@ IndexMarks *FFAudioStream::get_markers()
 }
 
 FFVideoStream::FFVideoStream(FFMPEG *ffmpeg, AVStream *strm, int idx, int fidx)
- : FFStream(ffmpeg, strm, fidx)
+ : FFStream(ffmpeg, strm, fidx),
+   FFVideoConvert(ffmpeg->ff_prefs())
 {
 	this->idx = idx;
 	width = height = 0;
@@ -1004,6 +1043,8 @@ FFVideoStream::FFVideoStream(FFMPEG *ffmpeg, AVStream *strm, int idx, int fidx)
 	length = 0;
 	interlaced = 0;
 	top_field_first = 0;
+	color_space = -1;
+	color_range = -1;
 }
 
 FFVideoStream::~FFVideoStream()
@@ -1016,7 +1057,8 @@ AVHWDeviceType FFVideoStream::decode_hw_activate()
 	const char *hw_dev = ffmpeg->opt_hw_dev;
 	if( !hw_dev ) hw_dev = getenv("CIN_HW_DEV");
 	if( !hw_dev ) hw_dev = ffmpeg->ff_hw_dev();
-	if( hw_dev && *hw_dev && strcmp(_("none"), hw_dev) ) {
+	if( hw_dev && *hw_dev &&
+	    strcmp("none", hw_dev) && strcmp(_("none"), hw_dev) ) {
 		type = av_hwdevice_find_type_by_name(hw_dev);
 		if( type == AV_HWDEVICE_TYPE_NONE ) {
 			fprintf(stderr, "Device type %s is not supported.\n", hw_dev);
@@ -1135,7 +1177,7 @@ int FFVideoStream::decode_frame(AVFrame *frame)
 	int first_frame = seeked;  seeked = 0;
 	int ret = avcodec_receive_frame(avctx, frame);
 	if( ret < 0 ) {
-		if( first_frame || ret == AVERROR(EAGAIN) ) return 0;
+		if( first_frame ) return 0;
 		if( ret == AVERROR(EAGAIN) ) return 0;
 		if( ret == AVERROR_EOF ) { st_eof(1); return 0; }
 		ff_err(ret, "FFVideoStream::decode_frame: Could not read video frame.\nfile:%s\n,",
@@ -1237,6 +1279,26 @@ int FFVideoStream::encode_frame(AVFrame *frame)
 		frame->interlaced_frame = interlaced;
 		frame->top_field_first = top_field_first;
 	}
+	if( frame && frame->format == AV_PIX_FMT_VAAPI ) { // ugly
+		int ret = avcodec_send_frame(avctx, frame);
+		for( int retry=MAX_RETRY; !ret && --retry>=0; ) {
+			FFPacket pkt;  av_init_packet(pkt);
+			pkt->data = NULL;  pkt->size = 0;
+			if( (ret=avcodec_receive_packet(avctx, pkt)) < 0 ) {
+				if( ret == AVERROR(EAGAIN) ) ret = 0; // weird
+				break;
+			}
+			ret = write_packet(pkt);
+			pkt->stream_index = 0;
+			av_packet_unref(pkt);
+		}
+		if( ret < 0 ) {
+			ff_err(ret, "FFStream::encode_frame: vaapi encode failed.\nfile: %s\n",
+				ffmpeg->fmt_ctx->url);
+			return -1;
+		}
+		return 0;
+	}
 	return FFStream::encode_frame(frame);
 }
 
@@ -1308,7 +1370,7 @@ int FFVideoConvert::convert_picture_vframe(VFrame *frame, AVFrame *ip)
 }
 
 int FFVideoConvert::convert_picture_vframe(VFrame *frame, AVFrame *ip, AVFrame *ipic)
-{
+{ // picture = vframe
 	int cmodel = frame->get_color_model();
 	AVPixelFormat ofmt = color_model_to_pix_fmt(cmodel);
 	if( ofmt == AV_PIX_FMT_NB ) return -1;
@@ -1362,6 +1424,32 @@ int FFVideoConvert::convert_picture_vframe(VFrame *frame, AVFrame *ip, AVFrame *
 				" sws_getCachedContext() failed\n");
 		return -1;
 	}
+
+	int color_range = 0;
+	switch( preferences->yuv_color_range ) {
+	case BC_COLORS_JPEG:  color_range = 1;  break;
+	case BC_COLORS_MPEG:  color_range = 0;  break;
+	}
+	int color_space = SWS_CS_ITU601;
+	switch( preferences->yuv_color_space ) {
+	case BC_COLORS_BT601:  color_space = SWS_CS_ITU601;  break;
+	case BC_COLORS_BT709:  color_space = SWS_CS_ITU709;  break;
+	case BC_COLORS_BT2020: color_space = SWS_CS_BT2020;  break;
+	}
+	const int *color_table = sws_getCoefficients(color_space);
+
+	int *inv_table, *table, src_range, dst_range;
+	int brightness, contrast, saturation;
+	if( !sws_getColorspaceDetails(convert_ctx,
+			&inv_table, &src_range, &table, &dst_range,
+			&brightness, &contrast, &saturation) ) {
+		if( src_range != color_range || dst_range != color_range ||
+		    inv_table != color_table || table != color_table )
+			sws_setColorspaceDetails(convert_ctx,
+					color_table, color_range, color_table, color_range,
+					brightness, contrast, saturation);
+	}
+
 	int ret = sws_scale(convert_ctx, ip->data, ip->linesize, 0, ip->height,
 	    ipic->data, ipic->linesize);
 	if( ret < 0 ) {
@@ -1426,7 +1514,7 @@ int FFVideoConvert::convert_vframe_picture(VFrame *frame, AVFrame *op)
 }
 
 int FFVideoConvert::convert_vframe_picture(VFrame *frame, AVFrame *op, AVFrame *opic)
-{
+{ // vframe = picture
 	int cmodel = frame->get_color_model();
 	AVPixelFormat ifmt = color_model_to_pix_fmt(cmodel);
 	if( ifmt == AV_PIX_FMT_NB ) return -1;
@@ -1464,6 +1552,32 @@ int FFVideoConvert::convert_vframe_picture(VFrame *frame, AVFrame *op, AVFrame *
 				" sws_getCachedContext() failed\n");
 		return -1;
 	}
+
+
+	int color_range = 0;
+	switch( preferences->yuv_color_range ) {
+	case BC_COLORS_JPEG:  color_range = 1;  break;
+	case BC_COLORS_MPEG:  color_range = 0;  break;
+	}
+	int color_space = SWS_CS_ITU601;
+	switch( preferences->yuv_color_space ) {
+	case BC_COLORS_BT601:  color_space = SWS_CS_ITU601;  break;
+	case BC_COLORS_BT709:  color_space = SWS_CS_ITU709;  break;
+	case BC_COLORS_BT2020: color_space = SWS_CS_BT2020;  break;
+	}
+	const int *color_table = sws_getCoefficients(color_space);
+
+	int *inv_table, *table, src_range, dst_range;
+	int brightness, contrast, saturation;
+	if( !sws_getColorspaceDetails(convert_ctx,
+			&inv_table, &src_range, &table, &dst_range,
+			&brightness, &contrast, &saturation) ) {
+		if( dst_range != color_range || table != color_table )
+			sws_setColorspaceDetails(convert_ctx,
+					inv_table, src_range, color_table, color_range,
+					brightness, contrast, saturation);
+	}
+
 	int ret = sws_scale(convert_ctx, opic->data, opic->linesize, 0, frame->get_h(),
 			op->data, op->linesize);
 	if( ret < 0 ) {
@@ -1546,6 +1660,8 @@ FFMPEG::FFMPEG(FileBase *file_base)
 	opt_video_filter = 0;
 	opt_audio_filter = 0;
 	opt_hw_dev = 0;
+	opt_video_decoder = 0;
+	opt_audio_decoder = 0;
 	fflags = 0;
 	char option_path[BCTEXTLEN];
 	set_option_path(option_path, "%s", "ffmpeg.opts");
@@ -1890,6 +2006,20 @@ void FFMPEG::load_video_options(Asset *asset, EDL *edl)
 		scan_video_options(asset, edl);
 }
 
+void FFMPEG::scan_format_options(Asset *asset, EDL *edl)
+{
+}
+
+void FFMPEG::load_format_options(Asset *asset, EDL *edl)
+{
+	char options_path[BCTEXTLEN];
+	set_option_path(options_path, "format/%s", asset->fformat);
+	if( !load_options(options_path,
+			asset->ff_format_options,
+			sizeof(asset->ff_format_options)) )
+		scan_format_options(asset, edl);
+}
+
 int FFMPEG::load_defaults(const char *path, const char *type,
 		 char *codec, char *codec_options, int len)
 {
@@ -1915,6 +2045,8 @@ void FFMPEG::set_asset_format(Asset *asset, EDL *edl, const char *text)
 	if( asset->format != FILE_FFMPEG ) return;
 	if( text != asset->fformat )
 		strcpy(asset->fformat, text);
+	if( !asset->ff_format_options[0] )
+		load_format_options(asset, edl);
 	if( asset->audio_data && !asset->ff_audio_options[0] ) {
 		if( !load_defaults("audio", text, asset->acodec,
 				asset->ff_audio_options, sizeof(asset->ff_audio_options)) )
@@ -1986,11 +2118,52 @@ int FFMPEG::scan_options(const char *options, AVDictionary *&opts, AVStream *st)
 	if( !fp ) return 0;
 	int ret = read_options(fp, options, opts);
 	fclose(fp);
-	AVDictionaryEntry *tag = av_dict_get(opts, "id", NULL, 0);
-	if( tag ) st->id = strtol(tag->value,0,0);
+	if( !ret && st ) {
+		AVDictionaryEntry *tag = av_dict_get(opts, "id", NULL, 0);
+		if( tag ) st->id = strtol(tag->value,0,0);
+	}
 	return ret;
 }
 
+FFCodecRemap::FFCodecRemap()
+{
+	old_codec = 0;
+	new_codec = 0;
+}
+FFCodecRemap::~FFCodecRemap()
+{
+	delete [] old_codec;
+	delete [] new_codec;
+}
+
+int FFCodecRemaps::add(const char *val)
+{
+	char old_codec[BCSTRLEN], new_codec[BCSTRLEN];
+	if( sscanf(val, " %63[a-zA-z0-9_-] = %63[a-z0-9_-]",
+		&old_codec[0], &new_codec[0]) != 2 ) return 1;
+	FFCodecRemap &remap = append();
+	remap.old_codec = cstrdup(old_codec);
+	remap.new_codec = cstrdup(new_codec);
+	return 0;
+}
+
+
+int FFCodecRemaps::update(AVCodecID &codec_id, AVCodec *&decoder)
+{
+	AVCodec *codec = avcodec_find_decoder(codec_id);
+	if( !codec ) return -1;
+	const char *name = codec->name;
+	FFCodecRemaps &map = *this;
+	int k = map.size();
+	while( --k >= 0 && strcmp(map[k].old_codec, name) );
+	if( k < 0 ) return 1;
+	const char *new_codec = map[k].new_codec;
+	codec = avcodec_find_decoder_by_name(new_codec);
+	if( !codec ) return -1;
+	decoder = codec;
+	return 0;
+}
+
 int FFMPEG::read_options(FILE *fp, const char *options, AVDictionary *&opts)
 {
 	int ret = 0, no = 0;
@@ -2007,6 +2180,14 @@ int FFMPEG::read_options(FILE *fp, const char *options, AVDictionary *&opts)
 		if( !ret ) {
 			if( !strcmp(key, "duration") )
 				opt_duration = strtod(val, 0);
+			else if( !strcmp(key, "video_decoder") )
+				opt_video_decoder = cstrdup(val);
+			else if( !strcmp(key, "audio_decoder") )
+				opt_audio_decoder = cstrdup(val);
+			else if( !strcmp(key, "remap_video_decoder") )
+				video_codec_remaps.add(val);
+			else if( !strcmp(key, "remap_audio_decoder") )
+				audio_codec_remaps.add(val);
 			else if( !strcmp(key, "video_filter") )
 				opt_video_filter = cstrdup(val);
 			else if( !strcmp(key, "audio_filter") )
@@ -2084,16 +2265,23 @@ int FFMPEG::info(char *text, int len)
 	if( ffvideo.size() > 0 )
 		report("\n%d video stream%s\n",ffvideo.size(), ffvideo.size()!=1 ? "s" : "");
 	for( int vidx=0; vidx<ffvideo.size(); ++vidx ) {
+		const char *unkn = _("(unkn)");
 		FFVideoStream *vid = ffvideo[vidx];
 		AVStream *st = vid->st;
 		AVCodecID codec_id = st->codecpar->codec_id;
 		report(_("vid%d (%d),  id 0x%06x:\n"), vid->idx, vid->fidx, codec_id);
 		const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
-		report("  video%d %s", vidx+1, desc ? desc->name : " (unkn)");
+		report("  video%d %s ", vidx+1, desc ? desc->name : unkn);
 		report(" %dx%d %5.2f", vid->width, vid->height, vid->frame_rate);
 		AVPixelFormat pix_fmt = (AVPixelFormat)st->codecpar->format;
 		const char *pfn = av_get_pix_fmt_name(pix_fmt);
-		report(" pix %s\n", pfn ? pfn : "(unkn)");
+		report(" pix %s\n", pfn ? pfn : unkn);
+		enum AVColorSpace space = st->codecpar->color_space;
+		const char *nm = av_color_space_name(space);
+		report("    color space:%s", nm ? nm : unkn);
+    		enum AVColorRange range = st->codecpar->color_range;
+		const char *rg = av_color_range_name(range);
+		report("/ range:%s\n", rg ? rg : unkn);
 		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);
@@ -2254,6 +2442,35 @@ int FFMPEG::open_decoder()
 			vid->width = avpar->width;
 			vid->height = avpar->height;
 			vid->frame_rate = !framerate.den ? 0 : (double)framerate.num / framerate.den;
+			switch( avpar->color_range ) {
+			case AVCOL_RANGE_MPEG:
+				vid->color_range = BC_COLORS_MPEG;
+				break;
+			case AVCOL_RANGE_JPEG:
+				vid->color_range = BC_COLORS_JPEG;
+				break;
+			default:
+				vid->color_range = !file_base ? BC_COLORS_JPEG :
+					file_base->file->preferences->yuv_color_range;
+				break;
+			}
+			switch( avpar->color_space ) {
+			case AVCOL_SPC_BT470BG:
+			case AVCOL_SPC_SMPTE170M:
+				vid->color_space = BC_COLORS_BT601;
+				break;
+			case AVCOL_SPC_BT709:
+				vid->color_space = BC_COLORS_BT709;
+				break;
+			case AVCOL_SPC_BT2020_NCL:
+			case AVCOL_SPC_BT2020_CL:
+				vid->color_space = BC_COLORS_BT2020;
+				break;
+			default:
+				vid->color_space = !file_base ? BC_COLORS_BT601 :
+					file_base->file->preferences->yuv_color_space;
+				break;
+			}
 			double secs = to_secs(st->duration, st->time_base);
 			vid->length = secs * vid->frame_rate;
 			vid->aspect_ratio = (double)st->sample_aspect_ratio.num / st->sample_aspect_ratio.den;
@@ -2287,7 +2504,7 @@ int FFMPEG::open_decoder()
 	}
 	if( bad_time && !(fflags & FF_BAD_TIMES) ) {
 		fflags |= FF_BAD_TIMES;
-		printf("FFMPEG::open_decoder: some stream have bad times: %s\n",
+		printf(_("FFMPEG::open_decoder: some stream have bad times: %s\n"),
 			fmt_ctx->url);
 	}
 	ff_unlock();
@@ -2486,7 +2703,19 @@ int FFMPEG::open_encoder(const char *type, const char *spec)
 			vid->width = asset->width;
 			vid->height = asset->height;
 			vid->frame_rate = asset->frame_rate;
-
+			if( (vid->color_range = asset->ff_color_range) < 0 )
+				vid->color_range = file_base->file->preferences->yuv_color_range;
+			switch( vid->color_range ) {
+			case BC_COLORS_MPEG:  ctx->color_range = AVCOL_RANGE_MPEG;  break;
+			case BC_COLORS_JPEG:  ctx->color_range = AVCOL_RANGE_JPEG;  break;
+			}
+			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_BT709:  ctx->colorspace = AVCOL_SPC_BT709;      break;
+			case BC_COLORS_BT2020: ctx->colorspace = AVCOL_SPC_BT2020_NCL; break;
+			}
 			AVPixelFormat pix_fmt = av_get_pix_fmt(asset->ff_pixel_format);
 			if( opt_hw_dev != 0 ) {
 				AVHWDeviceType hw_type = vid->encode_hw_activate(opt_hw_dev);
@@ -2776,7 +3005,13 @@ int FFMPEG::encode_activate()
 		char option_path[BCTEXTLEN];
 		set_option_path(option_path, "format/%s", file_format);
 		read_options(option_path, fopts, 1);
-		ret = avformat_write_header(fmt_ctx, &fopts);
+		av_dict_copy(&fopts, opts, 0);
+		if( scan_options(file_base->asset->ff_format_options, fopts, 0) ) {
+			eprintf(_("bad format options %s\n"), file_base->asset->path);
+			ret = -1;
+		}
+		if( ret >= 0 )
+			ret = avformat_write_header(fmt_ctx, &fopts);
 		if( ret < 0 ) {
 			ff_err(ret, "FFMPEG::encode_activate: write header failed %s\n",
 				fmt_ctx->url);
@@ -3091,6 +3326,16 @@ const char* FFMPEG::ff_video_format(int stream)
 	return desc ? desc->name : _("Unknown");
 }
 
+int FFMPEG::ff_color_range(int stream)
+{
+	return ffvideo[stream]->color_range;
+}
+
+int FFMPEG::ff_color_space(int stream)
+{
+	return ffvideo[stream]->color_space;
+}
+
 double FFMPEG::ff_frame_rate(int stream)
 {
 	return ffvideo[stream]->frame_rate;
@@ -3121,6 +3366,11 @@ const char *FFMPEG::ff_hw_dev()
 	return &file_base->file->preferences->use_hw_dev[0];
 }
 
+Preferences *FFMPEG::ff_prefs()
+{
+	return !file_base ? 0 : file_base->file->preferences;
+}
+
 int FFVideoStream::create_filter(const char *filter_spec, AVCodecParameters *avpar)
 {
 	avfilter_register_all();