Attachment #317071 for bug #419551





    AVFrame ff_venc_frame;
    AVCodecContext ff_vcontext;
    AVDictionary ** ff_opts;

    AVCodec *ff_vcodec;


    SET_FLAG(pd, mv0);
    SET_FLAG(pd, cbp);
    SET_FLAG(pd, qpel);
    SET_FLAG(pd, alt);
    SET_FLAG(pd, vdpart);
    SET_FLAG(pd, naq);
    SET_FLAG(pd, ilme);
    SET_FLAG(pd, ildct);
    SET_FLAG(pd, aic);
    SET_FLAG(pd, aiv);
    SET_FLAG(pd, umv);
    SET_FLAG(pd, psnr);
    SET_FLAG(pd, trell);
    SET_FLAG(pd, gray);

        pd->ff_vcontext.flags |= CODEC_FLAG_INTERLACED_DCT;
        pd->ff_vcontext.flags |= CODEC_FLAG_INTERLACED_ME;
    }
    if (pd->confdata.flags.alt) {
        av_dict_set(pd->ff_opts, "alternate_scan", "1", 0);
    }
    if (pd->confdata.flags.vdpart) {
        av_dict_set(pd->ff_opts, "data_partitioning", "1", 0);
    }
    if (pd->confdata.flags.umv) {
        av_dict_set(pd->ff_opts, "umv", "1", 0);
    }
    if (pd->confdata.flags.aiv) {
        av_dict_set(pd->ff_opts, "aiv", "1", 0);
    }
}

#undef SET_FLAG

        { "mv0", PAUX(flags.mv0), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_MV0 },
        { "cbp", PAUX(flags.cbp), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_CBP_RD },
        { "qpel", PAUX(flags.qpel), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_QPEL },
        { "alt", PAUX(flags.alt), TCCONF_TYPE_FLAG, 0, 0, 1 },
        { "ilme", PAUX(flags.ilme), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_INTERLACED_ME },
        { "ildct", PAUX(flags.ildct), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_INTERLACED_DCT },
        { "naq", PAUX(flags.naq), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_NORMALIZE_AQP },
        { "vdpart", PAUX(flags.vdpart), TCCONF_TYPE_FLAG, 0, 0, 1 },
#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
        { "aic", PAUX(flags.aic), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_H263P_AIC },
#else        
        { "aic", PAUX(flags.aic), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_AC_PRED },
#endif
        { "aiv", PAUX(flags.aiv), TCCONF_TYPE_FLAG, 0, 0, 1 },
        { "umv", PAUX(flags.umv), TCCONF_TYPE_FLAG, 0, 0, 1 },
        { "psnr", PAUX(flags.psnr), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_PSNR },
#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
        { "trell", PAUX(flags.trell), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_TRELLIS_QUANT },

                    pd->confdata.thread_count,
                    (pd->confdata.thread_count > 1) ?"s" :"");
    }
    pd->ff_vcontext.thread_count = pd->confdata.thread_count;

    pd->ff_vcodec = avcodec_find_encoder(FF_VCODEC_ID(pd));
    if (pd->ff_vcodec == NULL) {

    }

    TC_LOCK_LIBAVCODEC;
    ret = avcodec_open2(&pd->ff_vcontext, pd->ff_vcodec, pd->ff_opts);
    TC_UNLOCK_LIBAVCODEC;

    if (ret < 0) {
        tc_log_error(MOD_NAME, "avcodec_open2() failed");
        goto failed;
    }
    /* finally, pass up the extradata, if any */




static AVFrame             *lavc_convert_frame = NULL;

static AVCodec             *lavc_venc_codec = NULL;
static AVDictionary        **lavc_venc_opts = NULL;
static AVFrame             *lavc_venc_frame = NULL;
static AVCodecContext      *lavc_venc_context;
static avi_t               *avifile = NULL;



/* START: COPIED FROM ffmpeg-0.5_p22846(ffmpeg.c, cmdutils.c) */
#include <libavutil/opt.h>
#include <libavutil/avstring.h>
#include <libswscale/swscale.h>


    }

    TC_LOCK_LIBAVCODEC;
    avcodec_init();
    avcodec_register_all();
    TC_UNLOCK_LIBAVCODEC;


        lavc_param_rc_max_rate = 2516;
        lavc_param_rc_buffer_size = 224 * 8;
        lavc_param_rc_buffer_aggressivity = 99;
        lavc_param_scan_offset = 1;

        break;



        lavc_param_rc_buffer_size = 224 * 8;
        lavc_param_rc_buffer_aggressivity = 99;
        lavc_param_scan_offset = 1;

        break;


		    lavc_venc_context->thread_count);
    }

    lavc_venc_context->thread_count = lavc_param_threads;

    if (lavc_param_intra_matrix) {
        char *tmp;

    lavc_venc_context->flags |= lavc_param_closedgop;
    lavc_venc_context->flags |= lavc_param_trunc;
    lavc_venc_context->flags |= lavc_param_aic;
    lavc_venc_context->flags |= lavc_param_umv;
    lavc_venc_context->flags |= lavc_param_v4mv;
    lavc_venc_context->flags |= lavc_param_data_partitioning;
    lavc_venc_context->flags |= lavc_param_cbp;
    lavc_venc_context->flags |= lavc_param_mv0;
    lavc_venc_context->flags |= lavc_param_qp_rd;
    lavc_venc_context->flags |= lavc_param_scan_offset;
    lavc_venc_context->flags |= lavc_param_ss;
    lavc_venc_context->flags |= lavc_param_alt;
    lavc_venc_context->flags |= lavc_param_ilme;
#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)   
    lavc_venc_context->flags |= lavc_param_trell;


    lavc_venc_context->me_method = ME_ZERO + lavc_param_vme;


	/* FIXME: transcode itself contains "broken ffmpeg default settings", thus we need to override them! */
	if (lavc_param_video_preset) {
		avcodec_opts[AVMEDIA_TYPE_VIDEO] = lavc_venc_context;

		}
	}

    if (lavc_param_scan_offset) {
      av_dict_set(lavc_venc_opts, "scan_offset", "1", 0);
    }

    if (lavc_param_ss) {
      av_dict_set(lavc_venc_opts, "structured_slices", "1", 0);
    }

    if (lavc_param_alt) {
      av_dict_set(lavc_venc_opts, "alternate_scan", "1", 0);
    }

    if (lavc_param_umv) {
      av_dict_set(lavc_venc_opts, "umv", "1", 0);
    }

    if (lavc_param_data_partitioning) {
      av_dict_set(lavc_venc_opts, "vdpart", "1", 0);
    }

    //-- open codec --
    //----------------
    TC_LOCK_LIBAVCODEC;
    ret = avcodec_open2(lavc_venc_context, lavc_venc_codec, lavc_venc_opts);
    TC_UNLOCK_LIBAVCODEC;
    if (ret < 0) {
      tc_log_warn(MOD_NAME, "could not open FFMPEG codec");
      return TC_EXPORT_ERROR;
    }

    if (av_codec_is_encoder(lavc_venc_context->codec) == 0) {
      tc_log_warn(MOD_NAME, "could not open FFMPEG codec "
              "(av_codec_is_encoder(lavc_venc_context->codec) == 0)");
      return TC_EXPORT_ERROR;
    }





    {"vcelim", &lavc_param_chroma_elim_threshold, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -99, 99},
    {"vpsize", &lavc_param_packet_size, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 100000000},
    {"vstrict", &lavc_param_strict, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -99, 99},
    {"vdpart", &lavc_param_data_partitioning, TCCONF_TYPE_FLAG, 0, 0, 1},
//    {"keyint", &lavc_param_keyint, TCCONF_TYPE_INT, 0, 0, 0},
    {"gray", &lavc_param_gray, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_GRAY},
    {"mpeg_quant", &lavc_param_mpeg_quant, TCCONF_TYPE_FLAG, 0, 0, 1},
    {"vi_qfactor", &lavc_param_vi_qfactor, TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, -31.0, 31.0},
    {"vi_qoffset", &lavc_param_vi_qoffset, TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 31.0},

#else
    {"aic", &lavc_param_aic, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_AC_PRED},
#endif    
    {"umv", &lavc_param_umv, TCCONF_TYPE_FLAG, 0, 0, 1},
    {"ibias", &lavc_param_ibias, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -512, 512},
    {"pbias", &lavc_param_pbias, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -512, 512},
    {"coder", &lavc_param_coder, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 10},

    {"nr", &lavc_param_noise_reduction, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 1000000},
    {"qprd", &lavc_param_qp_rd, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_QP_RD},
    {"threads", &lavc_param_threads, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 16},
    {"ss", &lavc_param_ss, TCCONF_TYPE_FLAG, 0, 0, 1},
    {"svcd_sof", &lavc_param_scan_offset, TCCONF_TYPE_FLAG, 0, 0, 1},
    {"alt", &lavc_param_alt, TCCONF_TYPE_FLAG, 0, 0, 1},
    {"ilme", &lavc_param_ilme, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_INTERLACED_ME},
    {"inter_threshold", &lavc_param_inter_threshold, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -1000000, 1000000},
    {"sc_threshold", &lavc_param_sc_threshold, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -1000000, 1000000},

Lines 181-187 Link Here

(-)transcode-1.1.7-orig/import/decode_lavc.c (-1 / +1 lines)
181	#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)	181	#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
182	lavc_dec_context->error_resilience = 2;	182	lavc_dec_context->error_resilience = 2;
183	#else	183	#else
184	lavc_dec_context->error_recognition = 2;	184	lavc_dec_context->err_recognition = 2;
185	#endif	185	#endif
186	lavc_dec_context->error_concealment = 3;	186	lavc_dec_context->error_concealment = 3;
187	lavc_dec_context->workaround_bugs = FF_BUG_AUTODETECT;	187	lavc_dec_context->workaround_bugs = FF_BUG_AUTODETECT;

Lines 314-320 Link Here

(-)transcode-1.1.7-orig/import/import_ffmpeg.c (-1 / +1 lines)
314	#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)	314	#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
315	lavc_dec_context->error_resilience = 2;	315	lavc_dec_context->error_resilience = 2;
316	#else	316	#else
317	lavc_dec_context->error_recognition = 2;	317	lavc_dec_context->err_recognition = 2;
318	#endif	318	#endif
319	lavc_dec_context->error_concealment = 3;	319	lavc_dec_context->error_concealment = 3;
320	lavc_dec_context->workaround_bugs = FF_BUG_AUTODETECT;	320	lavc_dec_context->workaround_bugs = FF_BUG_AUTODETECT;

Lines 99-106 Link Here

(-)transcode-1.1.7-orig/import/probe_ffmpeg.c (-2 / +2 lines)
99		99
100	TC_INIT_LIBAVCODEC;	100	TC_INIT_LIBAVCODEC;
101		101
102	ret = av_open_input_file(&lavf_dmx_context, ipipe->name,	102	ret = avformat_open_input(&lavf_dmx_context, ipipe->name,
103	NULL, 0, NULL);	103	NULL, NULL);
104	if (ret != 0) {	104	if (ret != 0) {
105	tc_log_error(__FILE__, "unable to open '%s'"	105	tc_log_error(__FILE__, "unable to open '%s'"
106	" (libavformat failure)",	106	" (libavformat failure)",

Lines 53-59 Link Here

(-)transcode-1.1.7-orig/libtc/tcavcodec.h (-1 lines)
53		53
54	#define TC_INIT_LIBAVCODEC do { \	54	#define TC_INIT_LIBAVCODEC do { \
55	TC_LOCK_LIBAVCODEC; \	55	TC_LOCK_LIBAVCODEC; \
56	avcodec_init(); \
57	avcodec_register_all(); \	56	avcodec_register_all(); \
58	TC_UNLOCK_LIBAVCODEC; \	57	TC_UNLOCK_LIBAVCODEC; \
59	} while (0)	58	} while (0)

Return to bug 419551

Lines 114-119 Link Here

(-)transcode-1.1.7-orig/encode/encode_lavc.c (-11 / +20 lines)
114		114
115	AVFrame ff_venc_frame;	115	AVFrame ff_venc_frame;
116	AVCodecContext ff_vcontext;	116	AVCodecContext ff_vcontext;
		117	AVDictionary ** ff_opts;
117		118
118	AVCodec *ff_vcodec;	119	AVCodec *ff_vcodec;
119		120
Lines 1036-1049 Link Here
1036	SET_FLAG(pd, mv0);	1037	SET_FLAG(pd, mv0);
1037	SET_FLAG(pd, cbp);	1038	SET_FLAG(pd, cbp);
1038	SET_FLAG(pd, qpel);	1039	SET_FLAG(pd, qpel);
1039	SET_FLAG(pd, alt);
1040	SET_FLAG(pd, vdpart);
1041	SET_FLAG(pd, naq);	1040	SET_FLAG(pd, naq);
1042	SET_FLAG(pd, ilme);	1041	SET_FLAG(pd, ilme);
1043	SET_FLAG(pd, ildct);	1042	SET_FLAG(pd, ildct);
1044	SET_FLAG(pd, aic);	1043	SET_FLAG(pd, aic);
1045	SET_FLAG(pd, aiv);
1046	SET_FLAG(pd, umv);
1047	SET_FLAG(pd, psnr);	1044	SET_FLAG(pd, psnr);
1048	SET_FLAG(pd, trell);	1045	SET_FLAG(pd, trell);
1049	SET_FLAG(pd, gray);	1046	SET_FLAG(pd, gray);
Lines 1064-1069 Link Here
1064	pd->ff_vcontext.flags \|= CODEC_FLAG_INTERLACED_DCT;	1061	pd->ff_vcontext.flags \|= CODEC_FLAG_INTERLACED_DCT;
1065	pd->ff_vcontext.flags \|= CODEC_FLAG_INTERLACED_ME;	1062	pd->ff_vcontext.flags \|= CODEC_FLAG_INTERLACED_ME;
1066	}	1063	}
		1064	if (pd->confdata.flags.alt) {
		1065	av_dict_set(pd->ff_opts, "alternate_scan", "1", 0);
		1066	}
		1067	if (pd->confdata.flags.vdpart) {
		1068	av_dict_set(pd->ff_opts, "data_partitioning", "1", 0);
		1069	}
		1070	if (pd->confdata.flags.umv) {
		1071	av_dict_set(pd->ff_opts, "umv", "1", 0);
		1072	}
		1073	if (pd->confdata.flags.aiv) {
		1074	av_dict_set(pd->ff_opts, "aiv", "1", 0);
		1075	}
1067	}	1076	}
1068		1077
1069	#undef SET_FLAG	1078	#undef SET_FLAG
Lines 1184-1201 Link Here
1184	{ "mv0", PAUX(flags.mv0), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_MV0 },	1193	{ "mv0", PAUX(flags.mv0), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_MV0 },
1185	{ "cbp", PAUX(flags.cbp), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_CBP_RD },	1194	{ "cbp", PAUX(flags.cbp), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_CBP_RD },
1186	{ "qpel", PAUX(flags.qpel), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_QPEL },	1195	{ "qpel", PAUX(flags.qpel), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_QPEL },
1187	{ "alt", PAUX(flags.alt), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_ALT_SCAN },	1196	{ "alt", PAUX(flags.alt), TCCONF_TYPE_FLAG, 0, 0, 1 },
1188	{ "ilme", PAUX(flags.ilme), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_INTERLACED_ME },	1197	{ "ilme", PAUX(flags.ilme), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_INTERLACED_ME },
1189	{ "ildct", PAUX(flags.ildct), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_INTERLACED_DCT },	1198	{ "ildct", PAUX(flags.ildct), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_INTERLACED_DCT },
1190	{ "naq", PAUX(flags.naq), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_NORMALIZE_AQP },	1199	{ "naq", PAUX(flags.naq), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_NORMALIZE_AQP },
1191	{ "vdpart", PAUX(flags.vdpart), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_PART },	1200	{ "vdpart", PAUX(flags.vdpart), TCCONF_TYPE_FLAG, 0, 0, 1 },
1192	#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)	1201	#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
1193	{ "aic", PAUX(flags.aic), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_H263P_AIC },	1202	{ "aic", PAUX(flags.aic), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_H263P_AIC },
1194	#else	1203	#else
1195	{ "aic", PAUX(flags.aic), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_AC_PRED },	1204	{ "aic", PAUX(flags.aic), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_AC_PRED },
1196	#endif	1205	#endif
1197	{ "aiv", PAUX(flags.aiv), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_H263P_AIV },	1206	{ "aiv", PAUX(flags.aiv), TCCONF_TYPE_FLAG, 0, 0, 1 },
1198	{ "umv", PAUX(flags.umv), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_H263P_UMV },	1207	{ "umv", PAUX(flags.umv), TCCONF_TYPE_FLAG, 0, 0, 1 },
1199	{ "psnr", PAUX(flags.psnr), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_PSNR },	1208	{ "psnr", PAUX(flags.psnr), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_PSNR },
1200	#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)	1209	#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
1201	{ "trell", PAUX(flags.trell), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_TRELLIS_QUANT },	1210	{ "trell", PAUX(flags.trell), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_TRELLIS_QUANT },
Lines 1387-1393 Link Here
1387	pd->confdata.thread_count,	1396	pd->confdata.thread_count,
1388	(pd->confdata.thread_count > 1) ?"s" :"");	1397	(pd->confdata.thread_count > 1) ?"s" :"");
1389	}	1398	}
1390	avcodec_thread_init(&pd->ff_vcontext, pd->confdata.thread_count);	1399	pd->ff_vcontext.thread_count = pd->confdata.thread_count;
1391		1400
1392	pd->ff_vcodec = avcodec_find_encoder(FF_VCODEC_ID(pd));	1401	pd->ff_vcodec = avcodec_find_encoder(FF_VCODEC_ID(pd));
1393	if (pd->ff_vcodec == NULL) {	1402	if (pd->ff_vcodec == NULL) {
Lines 1397-1407 Link Here
1397	}	1406	}
1398		1407
1399	TC_LOCK_LIBAVCODEC;	1408	TC_LOCK_LIBAVCODEC;
1400	ret = avcodec_open(&pd->ff_vcontext, pd->ff_vcodec);	1409	ret = avcodec_open2(&pd->ff_vcontext, pd->ff_vcodec, pd->ff_opts);
1401	TC_UNLOCK_LIBAVCODEC;	1410	TC_UNLOCK_LIBAVCODEC;
1402		1411
1403	if (ret < 0) {	1412	if (ret < 0) {
1404	tc_log_error(MOD_NAME, "avcodec_open() failed");	1413	tc_log_error(MOD_NAME, "avcodec_open2() failed");
1405	goto failed;	1414	goto failed;
1406	}	1415	}
1407	/* finally, pass up the extradata, if any */	1416	/* finally, pass up the extradata, if any */

Lines 122-127 Link Here

(-)transcode-1.1.7-orig/export/export_ffmpeg.c (-14 / +27 lines)
122	static AVFrame *lavc_convert_frame = NULL;	122	static AVFrame *lavc_convert_frame = NULL;
123		123
124	static AVCodec *lavc_venc_codec = NULL;	124	static AVCodec *lavc_venc_codec = NULL;
		125	static AVDictionary **lavc_venc_opts = NULL;
125	static AVFrame *lavc_venc_frame = NULL;	126	static AVFrame *lavc_venc_frame = NULL;
126	static AVCodecContext *lavc_venc_context;	127	static AVCodecContext *lavc_venc_context;
127	static avi_t *avifile = NULL;	128	static avi_t *avifile = NULL;
Lines 180-186 Link Here
180		181
181		182
182	/* START: COPIED FROM ffmpeg-0.5_p22846(ffmpeg.c, cmdutils.c) */	183	/* START: COPIED FROM ffmpeg-0.5_p22846(ffmpeg.c, cmdutils.c) */
183	#include <libavcodec/opt.h>	184	#include <libavutil/opt.h>
184	#include <libavutil/avstring.h>	185	#include <libavutil/avstring.h>
185	#include <libswscale/swscale.h>	186	#include <libswscale/swscale.h>
186		187
Lines 470-476 Link Here
470	}	471	}
471		472
472	TC_LOCK_LIBAVCODEC;	473	TC_LOCK_LIBAVCODEC;
473	avcodec_init();
474	avcodec_register_all();	474	avcodec_register_all();
475	TC_UNLOCK_LIBAVCODEC;	475	TC_UNLOCK_LIBAVCODEC;
476		476
Lines 634-640 Link Here
634	lavc_param_rc_max_rate = 2516;	634	lavc_param_rc_max_rate = 2516;
635	lavc_param_rc_buffer_size = 224 * 8;	635	lavc_param_rc_buffer_size = 224 * 8;
636	lavc_param_rc_buffer_aggressivity = 99;	636	lavc_param_rc_buffer_aggressivity = 99;
637	lavc_param_scan_offset = CODEC_FLAG_SVCD_SCAN_OFFSET;	637	lavc_param_scan_offset = 1;
638		638
639	break;	639	break;
640		640
Lines 674-680 Link Here
674		674
675	lavc_param_rc_buffer_size = 224 * 8;	675	lavc_param_rc_buffer_size = 224 * 8;
676	lavc_param_rc_buffer_aggressivity = 99;	676	lavc_param_rc_buffer_aggressivity = 99;
677	lavc_param_scan_offset = CODEC_FLAG_SVCD_SCAN_OFFSET;	677	lavc_param_scan_offset = 1;
678		678
679	break;	679	break;
680		680
Lines 887-893 Link Here
887	lavc_venc_context->thread_count);	887	lavc_venc_context->thread_count);
888	}	888	}
889		889
890	avcodec_thread_init(lavc_venc_context, lavc_param_threads);	890	lavc_venc_context->thread_count = lavc_param_threads;
891		891
892	if (lavc_param_intra_matrix) {	892	if (lavc_param_intra_matrix) {
893	char *tmp;	893	char *tmp;
Lines 1065-1079 Link Here
1065	lavc_venc_context->flags \|= lavc_param_closedgop;	1065	lavc_venc_context->flags \|= lavc_param_closedgop;
1066	lavc_venc_context->flags \|= lavc_param_trunc;	1066	lavc_venc_context->flags \|= lavc_param_trunc;
1067	lavc_venc_context->flags \|= lavc_param_aic;	1067	lavc_venc_context->flags \|= lavc_param_aic;
1068	lavc_venc_context->flags \|= lavc_param_umv;
1069	lavc_venc_context->flags \|= lavc_param_v4mv;	1068	lavc_venc_context->flags \|= lavc_param_v4mv;
1070	lavc_venc_context->flags \|= lavc_param_data_partitioning;
1071	lavc_venc_context->flags \|= lavc_param_cbp;	1069	lavc_venc_context->flags \|= lavc_param_cbp;
1072	lavc_venc_context->flags \|= lavc_param_mv0;	1070	lavc_venc_context->flags \|= lavc_param_mv0;
1073	lavc_venc_context->flags \|= lavc_param_qp_rd;	1071	lavc_venc_context->flags \|= lavc_param_qp_rd;
1074	lavc_venc_context->flags \|= lavc_param_scan_offset;
1075	lavc_venc_context->flags \|= lavc_param_ss;
1076	lavc_venc_context->flags \|= lavc_param_alt;
1077	lavc_venc_context->flags \|= lavc_param_ilme;	1072	lavc_venc_context->flags \|= lavc_param_ilme;
1078	#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)	1073	#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
1079	lavc_venc_context->flags \|= lavc_param_trell;	1074	lavc_venc_context->flags \|= lavc_param_trell;
Lines 1203-1209 Link Here
1203		1198
1204	lavc_venc_context->me_method = ME_ZERO + lavc_param_vme;	1199	lavc_venc_context->me_method = ME_ZERO + lavc_param_vme;
1205		1200
1206
1207	/* FIXME: transcode itself contains "broken ffmpeg default settings", thus we need to override them! */	1201	/* FIXME: transcode itself contains "broken ffmpeg default settings", thus we need to override them! */
1208	if (lavc_param_video_preset) {	1202	if (lavc_param_video_preset) {
1209	avcodec_opts[AVMEDIA_TYPE_VIDEO] = lavc_venc_context;	1203	avcodec_opts[AVMEDIA_TYPE_VIDEO] = lavc_venc_context;
Lines 1241-1260 Link Here
1241	}	1235	}
1242	}	1236	}
1243		1237
		1238	if (lavc_param_scan_offset) {
		1239	av_dict_set(lavc_venc_opts, "scan_offset", "1", 0);
		1240	}
		1241
		1242	if (lavc_param_ss) {
		1243	av_dict_set(lavc_venc_opts, "structured_slices", "1", 0);
		1244	}
		1245
		1246	if (lavc_param_alt) {
		1247	av_dict_set(lavc_venc_opts, "alternate_scan", "1", 0);
		1248	}
		1249
		1250	if (lavc_param_umv) {
		1251	av_dict_set(lavc_venc_opts, "umv", "1", 0);
		1252	}
		1253
		1254	if (lavc_param_data_partitioning) {
		1255	av_dict_set(lavc_venc_opts, "vdpart", "1", 0);
		1256	}
1244		1257
1245	//-- open codec --	1258	//-- open codec --
1246	//----------------	1259	//----------------
1247	TC_LOCK_LIBAVCODEC;	1260	TC_LOCK_LIBAVCODEC;
1248	ret = avcodec_open(lavc_venc_context, lavc_venc_codec);	1261	ret = avcodec_open2(lavc_venc_context, lavc_venc_codec, lavc_venc_opts);
1249	TC_UNLOCK_LIBAVCODEC;	1262	TC_UNLOCK_LIBAVCODEC;
1250	if (ret < 0) {	1263	if (ret < 0) {
1251	tc_log_warn(MOD_NAME, "could not open FFMPEG codec");	1264	tc_log_warn(MOD_NAME, "could not open FFMPEG codec");
1252	return TC_EXPORT_ERROR;	1265	return TC_EXPORT_ERROR;
1253	}	1266	}
1254		1267
1255	if (lavc_venc_context->codec->encode == NULL) {	1268	if (av_codec_is_encoder(lavc_venc_context->codec) == 0) {
1256	tc_log_warn(MOD_NAME, "could not open FFMPEG codec "	1269	tc_log_warn(MOD_NAME, "could not open FFMPEG codec "
1257	"(lavc_venc_context->codec->encode == NULL)");	1270	"(av_codec_is_encoder(lavc_venc_context->codec) == 0)");
1258	return TC_EXPORT_ERROR;	1271	return TC_EXPORT_ERROR;
1259	}	1272	}
1260		1273

Lines 160-168 Link Here

(-)transcode-1.1.7-orig/export/ffmpeg_cfg.c (-6 / +6 lines)
160	{"vcelim", &lavc_param_chroma_elim_threshold, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -99, 99},	160	{"vcelim", &lavc_param_chroma_elim_threshold, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -99, 99},
161	{"vpsize", &lavc_param_packet_size, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 100000000},	161	{"vpsize", &lavc_param_packet_size, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 100000000},
162	{"vstrict", &lavc_param_strict, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -99, 99},	162	{"vstrict", &lavc_param_strict, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -99, 99},
163	{"vdpart", &lavc_param_data_partitioning, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_PART},	163	{"vdpart", &lavc_param_data_partitioning, TCCONF_TYPE_FLAG, 0, 0, 1},
164	// {"keyint", &lavc_param_keyint, TCCONF_TYPE_INT, 0, 0, 0},	164	// {"keyint", &lavc_param_keyint, TCCONF_TYPE_INT, 0, 0, 0},
165	{"gray", &lavc_param_gray, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_PART},	165	{"gray", &lavc_param_gray, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_GRAY},
166	{"mpeg_quant", &lavc_param_mpeg_quant, TCCONF_TYPE_FLAG, 0, 0, 1},	166	{"mpeg_quant", &lavc_param_mpeg_quant, TCCONF_TYPE_FLAG, 0, 0, 1},
167	{"vi_qfactor", &lavc_param_vi_qfactor, TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, -31.0, 31.0},	167	{"vi_qfactor", &lavc_param_vi_qfactor, TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, -31.0, 31.0},
168	{"vi_qoffset", &lavc_param_vi_qoffset, TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 31.0},	168	{"vi_qoffset", &lavc_param_vi_qoffset, TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 31.0},
Lines 211-217 Link Here
211	#else	211	#else
212	{"aic", &lavc_param_aic, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_AC_PRED},	212	{"aic", &lavc_param_aic, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_AC_PRED},
213	#endif	213	#endif
214	{"umv", &lavc_param_umv, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_H263P_UMV},	214	{"umv", &lavc_param_umv, TCCONF_TYPE_FLAG, 0, 0, 1},
215	{"ibias", &lavc_param_ibias, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -512, 512},	215	{"ibias", &lavc_param_ibias, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -512, 512},
216	{"pbias", &lavc_param_pbias, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -512, 512},	216	{"pbias", &lavc_param_pbias, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -512, 512},
217	{"coder", &lavc_param_coder, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 10},	217	{"coder", &lavc_param_coder, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 10},
Lines 223-231 Link Here
223	{"nr", &lavc_param_noise_reduction, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 1000000},	223	{"nr", &lavc_param_noise_reduction, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 1000000},
224	{"qprd", &lavc_param_qp_rd, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_QP_RD},	224	{"qprd", &lavc_param_qp_rd, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_QP_RD},
225	{"threads", &lavc_param_threads, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 16},	225	{"threads", &lavc_param_threads, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 16},
226	{"ss", &lavc_param_ss, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_H263P_SLICE_STRUCT},	226	{"ss", &lavc_param_ss, TCCONF_TYPE_FLAG, 0, 0, 1},
227	{"svcd_sof", &lavc_param_scan_offset, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_SVCD_SCAN_OFFSET},	227	{"svcd_sof", &lavc_param_scan_offset, TCCONF_TYPE_FLAG, 0, 0, 1},
228	{"alt", &lavc_param_alt, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_ALT_SCAN},	228	{"alt", &lavc_param_alt, TCCONF_TYPE_FLAG, 0, 0, 1},
229	{"ilme", &lavc_param_ilme, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_INTERLACED_ME},	229	{"ilme", &lavc_param_ilme, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_INTERLACED_ME},
230	{"inter_threshold", &lavc_param_inter_threshold, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -1000000, 1000000},	230	{"inter_threshold", &lavc_param_inter_threshold, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -1000000, 1000000},
231	{"sc_threshold", &lavc_param_sc_threshold, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -1000000, 1000000},	231	{"sc_threshold", &lavc_param_sc_threshold, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -1000000, 1000000},