Ticket #7470: transcode-1.1.7-ffmpeg3.patch

File transcode-1.1.7-ffmpeg3.patch, 48.8 KB (added by Armin K, 5 years ago)

transcode patch

  • encode/encode_lavc.c

    a b  
    7474    int lmin;
    7575    int lmax;
    7676    int me_method;
     77    int luma_elim_threshold;
     78    int chroma_elim_threshold;
     79    int quantizer_noise_shaping;
    7780
    7881    /* same as above for flags */
    7982    struct {
     
    114117
    115118    AVFrame ff_venc_frame;
    116119    AVCodecContext ff_vcontext;
     120    AVDictionary * ff_opts;
    117121
    118122    AVCodec *ff_vcodec;
    119123
     
    164168    TC_CODEC_ERROR
    165169};
    166170
     171#if LIBAVCODEC_VERSION_MAJOR < 55
    167172static const enum CodecID tc_lavc_internal_codecs[] = {
    168173    CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO, CODEC_ID_MPEG4,
    169174    CODEC_ID_H263I, CODEC_ID_H263P,
     
    176181    CODEC_ID_MSMPEG4V2, CODEC_ID_MSMPEG4V3,
    177182    CODEC_ID_NONE
    178183};
     184#else
     185static const enum AVCodecID tc_lavc_internal_codecs[] = {
     186    AV_CODEC_ID_MPEG1VIDEO, AV_CODEC_ID_MPEG2VIDEO, AV_CODEC_ID_MPEG4,
     187    AV_CODEC_ID_H263I, AV_CODEC_ID_H263P,
     188    AV_CODEC_ID_H264,
     189    AV_CODEC_ID_WMV1, AV_CODEC_ID_WMV2,
     190    AV_CODEC_ID_RV10,
     191    AV_CODEC_ID_HUFFYUV, AV_CODEC_ID_FFV1,
     192    AV_CODEC_ID_DVVIDEO,
     193    AV_CODEC_ID_MJPEG, AV_CODEC_ID_LJPEG,
     194    AV_CODEC_ID_MSMPEG4V2, AV_CODEC_ID_MSMPEG4V3,
     195    AV_CODEC_ID_NONE
     196};
     197#endif
    179198
    180199static const TCFormatID tc_lavc_formats[] = { TC_FORMAT_ERROR };
    181200
     
    214233                                     vframe_list_t *vframe)
    215234{
    216235    avpicture_fill((AVPicture *)&pd->ff_venc_frame, vframe->video_buf,
    217                     PIX_FMT_YUV420P,
     236                    AV_PIX_FMT_YUV420P,
    218237                    pd->ff_vcontext.width, pd->ff_vcontext.height);
    219238}
    220239
     
    228247                    IMG_YUV_DEFAULT,
    229248                    pd->ff_vcontext.width, pd->ff_vcontext.height);
    230249    avpicture_fill((AVPicture *)&pd->ff_venc_frame, pd->vframe_buf->video_buf,
    231                    PIX_FMT_YUV422P,
     250                   AV_PIX_FMT_YUV422P,
    232251                   pd->ff_vcontext.width, pd->ff_vcontext.height);
    233252    ac_imgconvert(src, IMG_YUV_DEFAULT,
    234253                  pd->ff_venc_frame.data, IMG_YUV422P,
     
    244263                    IMG_YUV422P,
    245264                    pd->ff_vcontext.width, pd->ff_vcontext.height);
    246265    avpicture_fill((AVPicture *)&pd->ff_venc_frame, pd->vframe_buf->video_buf,
    247                    PIX_FMT_YUV420P,
     266                   AV_PIX_FMT_YUV420P,
    248267                   pd->ff_vcontext.width, pd->ff_vcontext.height);
    249268    ac_imgconvert(src, IMG_YUV422P,
    250269                  pd->ff_venc_frame.data, IMG_YUV420P,
     
    256275                                             vframe_list_t *vframe)
    257276{
    258277    avpicture_fill((AVPicture *)&pd->ff_venc_frame, vframe->video_buf,
    259                    PIX_FMT_YUV422P,
     278                   AV_PIX_FMT_YUV422P,
    260279                   pd->ff_vcontext.width, pd->ff_vcontext.height);
    261280
    262281}
     
    266285                                   vframe_list_t *vframe)
    267286{
    268287    avpicture_fill((AVPicture *)&pd->ff_venc_frame, pd->vframe_buf->video_buf,
    269                    PIX_FMT_YUV420P,
     288                   AV_PIX_FMT_YUV420P,
    270289                   pd->ff_vcontext.width, pd->ff_vcontext.height);
    271290    ac_imgconvert(&vframe->video_buf, IMG_RGB_DEFAULT,
    272291                  pd->ff_venc_frame.data, IMG_YUV420P,
     
    591610      case CODEC_YUV:
    592611        if (TC_VCODEC_ID(pd) == TC_CODEC_HUFFYUV) {
    593612            pd->tc_pix_fmt = TC_CODEC_YUV422P;
    594             pd->ff_vcontext.pix_fmt = PIX_FMT_YUV422P;
     613            pd->ff_vcontext.pix_fmt = AV_PIX_FMT_YUV422P;
    595614            pd->pre_encode_video = pre_encode_video_yuv420p_huffyuv;
    596615        } else {
    597616            pd->tc_pix_fmt = TC_CODEC_YUV420P;
    598617            pd->ff_vcontext.pix_fmt = (TC_VCODEC_ID(pd) == TC_CODEC_MJPEG)
    599                                        ? PIX_FMT_YUVJ420P
    600                                        : PIX_FMT_YUV420P;
     618                                       ? AV_PIX_FMT_YUVJ420P
     619                                       : AV_PIX_FMT_YUV420P;
    601620            pd->pre_encode_video = pre_encode_video_yuv420p;
    602621        }
    603622        break;
    604623      case CODEC_YUV422:
    605624        pd->tc_pix_fmt = TC_CODEC_YUV422P;
    606625        pd->ff_vcontext.pix_fmt = (TC_VCODEC_ID(pd) == TC_CODEC_MJPEG)
    607                                    ? PIX_FMT_YUVJ422P
    608                                    : PIX_FMT_YUV422P;
     626                                   ? AV_PIX_FMT_YUVJ422P
     627                                   : AV_PIX_FMT_YUV422P;
    609628        if (TC_VCODEC_ID(pd) == TC_CODEC_HUFFYUV) {
    610629            pd->pre_encode_video = pre_encode_video_yuv422p_huffyuv;
    611630        } else {
     
    615634      case CODEC_RGB:
    616635        pd->tc_pix_fmt = TC_CODEC_RGB;
    617636        pd->ff_vcontext.pix_fmt = (TC_VCODEC_ID(pd) == TC_CODEC_HUFFYUV)
    618                                         ? PIX_FMT_YUV422P
     637                                        ? AV_PIX_FMT_YUV422P
    619638                                        : (TC_VCODEC_ID(pd) == TC_CODEC_MJPEG)
    620                                            ? PIX_FMT_YUVJ420P
    621                                            : PIX_FMT_YUV420P;
     639                                           ? AV_PIX_FMT_YUVJ420P
     640                                           : AV_PIX_FMT_YUV420P;
    622641        pd->pre_encode_video = pre_encode_video_rgb24;
    623642        break;
    624643      default:
     
    937956static void tc_lavc_config_defaults(TCLavcPrivateData *pd)
    938957{
    939958    /* first of all reinitialize lavc data */
     959#if LIBAVCODEC_VERSION_MAJOR < 55
    940960    avcodec_get_context_defaults(&pd->ff_vcontext);
     961#else
     962    avcodec_get_context_defaults3(&pd->ff_vcontext, NULL);
     963#endif
    941964
    942965    pd->confdata.thread_count = 1;
    943966
     
    955978    /*
    956979     * context *transcode* (not libavcodec) defaults
    957980     */
    958     pd->ff_vcontext.mb_qmin                 = 2;
    959     pd->ff_vcontext.mb_qmax                 = 31;
    960981    pd->ff_vcontext.max_qdiff               = 3;
    961982    pd->ff_vcontext.max_b_frames            = 0;
    962983    pd->ff_vcontext.me_range                = 0;
     
    977998    pd->ff_vcontext.mpeg_quant              = 0;
    978999    pd->ff_vcontext.rc_initial_cplx         = 0.0;
    9791000    pd->ff_vcontext.rc_qsquish              = 1.0;
    980     pd->ff_vcontext.luma_elim_threshold     = 0;
    981     pd->ff_vcontext.chroma_elim_threshold   = 0;
     1001    pd->confdata.luma_elim_threshold     = 0;
     1002    pd->confdata.chroma_elim_threshold   = 0;
    9821003    pd->ff_vcontext.strict_std_compliance   = 0;
    9831004    pd->ff_vcontext.dct_algo                = FF_DCT_AUTO;
    9841005    pd->ff_vcontext.idct_algo               = FF_IDCT_AUTO;
     
    10021023    pd->ff_vcontext.intra_quant_bias        = FF_DEFAULT_QUANT_BIAS;
    10031024    pd->ff_vcontext.inter_quant_bias        = FF_DEFAULT_QUANT_BIAS;
    10041025    pd->ff_vcontext.noise_reduction         = 0;
    1005     pd->ff_vcontext.quantizer_noise_shaping = 0;
     1026    pd->confdata.quantizer_noise_shaping = 0;
    10061027    pd->ff_vcontext.flags                   = 0;
    10071028}
    10081029
     
    10331054    pd->ff_vcontext.me_method = ME_ZERO + pd->confdata.me_method;
    10341055
    10351056    pd->ff_vcontext.flags = 0;
    1036     SET_FLAG(pd, mv0);
    1037     SET_FLAG(pd, cbp);
    10381057    SET_FLAG(pd, qpel);
    1039     SET_FLAG(pd, alt);
    1040     SET_FLAG(pd, vdpart);
    1041     SET_FLAG(pd, naq);
    10421058    SET_FLAG(pd, ilme);
    10431059    SET_FLAG(pd, ildct);
    10441060    SET_FLAG(pd, aic);
    1045     SET_FLAG(pd, aiv);
    1046     SET_FLAG(pd, umv);
    10471061    SET_FLAG(pd, psnr);
    10481062    SET_FLAG(pd, trell);
    10491063    SET_FLAG(pd, gray);
     
    10641078        pd->ff_vcontext.flags |= CODEC_FLAG_INTERLACED_DCT;
    10651079        pd->ff_vcontext.flags |= CODEC_FLAG_INTERLACED_ME;
    10661080    }
     1081    if (pd->confdata.flags.alt) {
     1082        av_dict_set(&(pd->ff_opts), "alternate_scan", "1", 0);
     1083    }
     1084    if (pd->confdata.flags.vdpart) {
     1085        av_dict_set(&(pd->ff_opts), "data_partitioning", "1", 0);
     1086    }
     1087    if (pd->confdata.flags.umv) {
     1088        av_dict_set(&(pd->ff_opts), "umv", "1", 0);
     1089    }
     1090    if (pd->confdata.flags.aiv) {
     1091        av_dict_set(&(pd->ff_opts), "aiv", "1", 0);
     1092    }
     1093    if (pd->confdata.flags.cbp) {
     1094        av_dict_set(&(pd->ff_opts), "mpv_flags", "+cbp_rd", 0);
     1095    }
     1096    if (pd->confdata.flags.mv0) {
     1097        av_dict_set(&(pd->ff_opts), "mpv_flags", "+mv0", 0);
     1098    }
     1099    if (pd->confdata.flags.naq) {
     1100        av_dict_set(&(pd->ff_opts), "mpv_flags", "+naq", 0);
     1101    }
     1102
     1103    char buf[1024];
     1104#define set_dict_opt(val, opt) \
     1105    snprintf(buf, sizeof(buf), "%i", pd->confdata.val);\
     1106    av_dict_set(&(pd->ff_opts), opt, buf, 0)
     1107
     1108    set_dict_opt(luma_elim_threshold, "luma_elim_threshold");
     1109    set_dict_opt(chroma_elim_threshold, "chroma_elim_threshold");
     1110    set_dict_opt(quantizer_noise_shaping, "quantizer_noise_shaping");
    10671111}
    10681112
    10691113#undef SET_FLAG
     
    11161160        //  handled by transcode core
    11171161        //  { "vqmax", PCTX(qmax), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 60 },
    11181162        //  handled by transcode core
    1119         { "mbqmin", PCTX(mb_qmin), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 60 },
    1120         { "mbqmax", PCTX(mb_qmax), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 60 },
    11211163        { "lmin", PAUX(lmin), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.01, 255.0 },
    11221164        { "lmax", PAUX(lmax), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.01, 255.0 },
    11231165        { "vqdiff", PCTX(max_qdiff), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 31 },
    1124         { "vmax_b_frames", PCTX(max_b_frames), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, FF_MAX_B_FRAMES },
     1166        { "vmax_b_frames", PCTX(max_b_frames), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, INT_MAX },
    11251167        { "vme", PAUX(me_method), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 16, },
    11261168        { "me_range", PCTX(me_range), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 16000 },
    11271169        { "mbd", PCTX(mb_decision), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 3 },
     
    11501192        { "vrc_init_cplx", PCTX(rc_initial_cplx), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 9999999.0 },
    11511193        //  { "vrc_init_occupancy",   }, // not yet supported
    11521194        { "vqsquish", PCTX(rc_qsquish), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 99.0 },
    1153         { "vlelim", PCTX(luma_elim_threshold), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -99, 99 },
    1154         { "vcelim", PCTX(chroma_elim_threshold), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -99, 99 },
     1195        { "vlelim", PAUX(luma_elim_threshold), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -99, 99 },
     1196        { "vcelim", PAUX(chroma_elim_threshold), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -99, 99 },
    11551197        { "vstrict", PCTX(strict_std_compliance), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -99, 99 },
    11561198        { "vpsize", PCTX(rtp_payload_size), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 100000000 },
    11571199        { "dct", PCTX(dct_algo), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 10 },
     
    11771219        { "ibias", PCTX(intra_quant_bias), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -512, 512 },
    11781220        { "pbias", PCTX(inter_quant_bias), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -512, 512 },
    11791221        { "nr", PCTX(noise_reduction), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 1000000},
    1180         { "qns", PCTX(quantizer_noise_shaping), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 3 },
     1222        { "qns", PAUX(quantizer_noise_shaping), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 3 },
    11811223        { "inter_matrix_file", inter_matrix_file, TCCONF_TYPE_STRING, 0, 0, 0 },
    11821224        { "intra_matrix_file", intra_matrix_file, TCCONF_TYPE_STRING, 0, 0, 0 },
    11831225   
    1184         { "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 },
     1226        { "mv0", PAUX(flags.mv0), TCCONF_TYPE_FLAG, 0, 0, 1 },
     1227        { "cbp", PAUX(flags.cbp), TCCONF_TYPE_FLAG, 0, 0, 1 },
    11861228        { "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 },
     1229        { "alt", PAUX(flags.alt), TCCONF_TYPE_FLAG, 0, 0, 1 },
    11881230        { "ilme", PAUX(flags.ilme), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_INTERLACED_ME },
    11891231        { "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 },
    1191         { "vdpart", PAUX(flags.vdpart), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_PART },
     1232        { "naq", PAUX(flags.naq), TCCONF_TYPE_FLAG, 0, 0, 1 },
     1233        { "vdpart", PAUX(flags.vdpart), TCCONF_TYPE_FLAG, 0, 0, 1 },
    11921234#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
    11931235        { "aic", PAUX(flags.aic), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_H263P_AIC },
    11941236#else       
    11951237        { "aic", PAUX(flags.aic), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_AC_PRED },
    11961238#endif
    1197         { "aiv", PAUX(flags.aiv), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_H263P_AIV },
    1198         { "umv", PAUX(flags.umv), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_H263P_UMV },
     1239        { "aiv", PAUX(flags.aiv), TCCONF_TYPE_FLAG, 0, 0, 1 },
     1240        { "umv", PAUX(flags.umv), TCCONF_TYPE_FLAG, 0, 0, 1 },
    11991241        { "psnr", PAUX(flags.psnr), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_PSNR },
    12001242#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
    12011243        { "trell", PAUX(flags.trell), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_TRELLIS_QUANT },
     
    13451387
    13461388    pd = self->userdata;
    13471389
     1390    pd->ff_opts = NULL;
     1391
    13481392    pd->flush_flag = vob->encoder_flush;
    13491393   
    13501394    /* FIXME: move into core? */
    13511395    TC_INIT_LIBAVCODEC;
    13521396
    1353     avcodec_get_frame_defaults(&pd->ff_venc_frame);
     1397    av_frame_unref(&pd->ff_venc_frame);
    13541398    /*
    13551399     * auxiliary config data needs to be blanked too
    13561400     * before any other operation
     
    13871431                    pd->confdata.thread_count,
    13881432                    (pd->confdata.thread_count > 1) ?"s" :"");
    13891433    }
    1390     avcodec_thread_init(&pd->ff_vcontext, pd->confdata.thread_count);
     1434    pd->ff_vcontext.thread_count = pd->confdata.thread_count;
    13911435
    13921436    pd->ff_vcodec = avcodec_find_encoder(FF_VCODEC_ID(pd));
    13931437    if (pd->ff_vcodec == NULL) {
     
    13971441    }
    13981442
    13991443    TC_LOCK_LIBAVCODEC;
    1400     ret = avcodec_open(&pd->ff_vcontext, pd->ff_vcodec);
     1444    ret = avcodec_open2(&pd->ff_vcontext, pd->ff_vcodec, &(pd->ff_opts));
    14011445    TC_UNLOCK_LIBAVCODEC;
    14021446
    14031447    if (ret < 0) {
    1404         tc_log_error(MOD_NAME, "avcodec_open() failed");
     1448        tc_log_error(MOD_NAME, "avcodec_open2() failed");
    14051449        goto failed;
    14061450    }
    14071451    /* finally, pass up the extradata, if any */
     
    14831527                                vframe_list_t *outframe)
    14841528{
    14851529    TCLavcPrivateData *pd = NULL;
     1530    AVPacket pkt;
     1531    int ret, got_packet = 0;
    14861532
    14871533    TC_MODULE_SELF_CHECK(self, "encode_video");
    14881534
     
    14971543
    14981544    pd->pre_encode_video(pd, inframe);
    14991545
     1546    av_init_packet(&pkt);
     1547    pkt.data = outframe->video_buf;
     1548    pkt.size = inframe->video_size;
     1549
    15001550    TC_LOCK_LIBAVCODEC;
    1501     outframe->video_len = avcodec_encode_video(&pd->ff_vcontext,
    1502                                                outframe->video_buf,
    1503                                                inframe->video_size,
    1504                                                &pd->ff_venc_frame);
     1551    ret = avcodec_encode_video2(&pd->ff_vcontext,   &pkt,
     1552                                &pd->ff_venc_frame, &got_packet);
    15051553    TC_UNLOCK_LIBAVCODEC;
     1554    outframe->video_len = ret ? ret : pkt.size;
    15061555
    15071556    if (outframe->video_len < 0) {
    15081557        tc_log_warn(MOD_NAME, "encoder error: size (%i)",
  • export/aud_aux.c

    a b  
    326326
    327327    switch (o_codec) {
    328328      case   0x50:
    329         codeid = CODEC_ID_MP2;
     329        codeid = AV_CODEC_ID_MP2;
    330330        break;
    331331      case 0x2000:
    332         codeid = CODEC_ID_AC3;
     332        codeid = AV_CODEC_ID_AC3;
    333333        break;
    334334      default:
    335335        tc_warn("cannot init ffmpeg with %x", o_codec);
     
    346346
    347347    //-- set parameters (bitrate, channels and sample-rate) --
    348348    //--------------------------------------------------------
    349     avcodec_get_context_defaults(&mpa_ctx);
     349    avcodec_get_context_defaults3(&mpa_ctx, mpa_codec);
    350350#if LIBAVCODEC_VERSION_MAJOR < 53
    351351    mpa_ctx.codec_type  = CODEC_TYPE_AUDIO;
    352352#else
     
    359359    //-- open codec --
    360360    //----------------
    361361    TC_LOCK_LIBAVCODEC;
    362     ret = avcodec_open(&mpa_ctx, mpa_codec);
     362    ret = avcodec_open2(&mpa_ctx, mpa_codec, NULL);
    363363    TC_UNLOCK_LIBAVCODEC;
    364364    if (ret < 0) {
    365365        tc_warn("tc_audio_init_ffmpeg: could not open %s codec !",
    366                 (codeid == CODEC_ID_MP2) ?"mpa" :"ac3");
     366                (codeid == AV_CODEC_ID_MP2) ?"mpa" :"ac3");
    367367        return(TC_EXPORT_ERROR);
    368368    }
    369369
     
    846846#ifdef HAVE_FFMPEG
    847847    int  in_size, out_size;
    848848    char *in_buf;
     849    int got_packet;
     850    AVPacket avpkt = { 0 };
     851    AVFrame *frame = av_frame_alloc();
    849852
    850853    //-- input buffer and amount of bytes --
    851854    in_size = aud_size;
     
    866869
    867870    ac_memcpy(&mpa_buf[mpa_buf_ptr], in_buf, bytes_needed);
    868871
     872    frame->nb_samples = mpa_ctx.frame_size;
     873    avcodec_fill_audio_frame(frame, mpa_ctx.channels, mpa_ctx.sample_fmt, (const uint8_t *)mpa_buf, mpa_bytes_pf, 1);
     874    avpkt.data = output;
     875    avpkt.size = OUTPUT_SIZE;
    869876    TC_LOCK_LIBAVCODEC;
    870     out_size = avcodec_encode_audio(&mpa_ctx, (unsigned char *)output,
    871                     OUTPUT_SIZE, (short *)mpa_buf);
     877    out_size = avcodec_encode_audio2(&mpa_ctx, &avpkt, frame, &got_packet);
    872878    TC_UNLOCK_LIBAVCODEC;
     879    out_size = avpkt.size;
    873880    tc_audio_write(output, out_size, avifile);
    874881
    875882        in_size -= bytes_needed;
     
    884891
    885892    ac_memcpy(&mpa_buf[mpa_buf_ptr], aud_buffer, bytes_avail);
    886893        mpa_buf_ptr += bytes_avail;
     894        av_frame_free(&frame);
    887895        return (0);
    888896      }
    889897    } //bytes availabe from last call?
     
    893901    //----------------------------------------------------
    894902
    895903    while (in_size >= mpa_bytes_pf) {
     904      av_frame_unref(frame);
     905      frame->nb_samples = mpa_ctx.frame_size;
     906      avcodec_fill_audio_frame(frame, mpa_ctx.channels, mpa_ctx.sample_fmt, (const uint8_t *)in_buf, mpa_bytes_pf, 1);
     907      avpkt.data = output;
     908      avpkt.size = OUTPUT_SIZE;
    896909      TC_LOCK_LIBAVCODEC;
    897       out_size = avcodec_encode_audio(&mpa_ctx, (unsigned char *)output,
    898                       OUTPUT_SIZE, (short *)in_buf);
     910      out_size = avcodec_encode_audio2(&mpa_ctx, &avpkt, frame, &got_packet);
    899911      TC_UNLOCK_LIBAVCODEC;
     912      out_size = avpkt.size;
    900913
    901914      tc_audio_write(output, out_size, avifile);
    902915
     
    904917      in_buf  += mpa_bytes_pf;
    905918    }
    906919
     920    av_frame_free(&frame);
     921
    907922    //-- hold rest of bytes in mpa-buffer --
    908923    //--------------------------------------
    909924    if (in_size > 0) {
  • export/export_ffmpeg.c

    a b  
    122122static AVFrame             *lavc_convert_frame = NULL;
    123123
    124124static AVCodec             *lavc_venc_codec = NULL;
     125static AVDictionary        *lavc_venc_opts = NULL;
    125126static AVFrame             *lavc_venc_frame = NULL;
    126127static AVCodecContext      *lavc_venc_context;
    127128static avi_t               *avifile = NULL;
     
    180181
    181182
    182183/* START: COPIED FROM ffmpeg-0.5_p22846(ffmpeg.c, cmdutils.c) */
    183 #include <libavcodec/opt.h>
     184#include <libavutil/opt.h>
    184185#include <libavutil/avstring.h>
    185186#include <libswscale/swscale.h>
    186187
     
    249250    for(type=0; type<AVMEDIA_TYPE_NB && ret>= 0; type++){
    250251                /* GLUE: +if */
    251252                if (type == AVMEDIA_TYPE_VIDEO) {
    252         const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
    253         if(o2)
    254             ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
     253        o = av_opt_find(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
     254        if(o)
     255            ret = av_opt_set(avcodec_opts[type], opt, arg, 0);
    255256                /* GLUE: +if */
    256257                }
    257258    }
     
    266267        if(opt[0] == 'a')
    267268            ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
    268269        else */ if(opt[0] == 'v')
    269             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
     270        {
     271            o = av_opt_find(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, NULL, 0, 0);
     272            ret = av_opt_set(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 0);
     273        }
    270274                /* GLUE: disabling
    271275        else if(opt[0] == 's')
    272276            ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
     
    470474    }
    471475
    472476    TC_LOCK_LIBAVCODEC;
    473     avcodec_init();
    474477    avcodec_register_all();
    475478    TC_UNLOCK_LIBAVCODEC;
    476479
     
    486489                            codec->name, codec->fourCC, codec->comments);
    487490    }
    488491
    489     lavc_venc_context = avcodec_alloc_context();
    490     lavc_venc_frame   = avcodec_alloc_frame();
     492    lavc_venc_context = avcodec_alloc_context3(lavc_venc_codec);
     493    lavc_venc_frame   = av_frame_alloc();
    491494
    492     lavc_convert_frame= avcodec_alloc_frame();
    493     size = avpicture_get_size(PIX_FMT_RGB24, vob->ex_v_width, vob->ex_v_height);
     495    lavc_convert_frame= av_frame_alloc();
     496    size = avpicture_get_size(AV_PIX_FMT_RGB24, vob->ex_v_width, vob->ex_v_height);
    494497    enc_buffer = tc_malloc(size);
    495498
    496499    if (lavc_venc_context == NULL || !enc_buffer || !lavc_convert_frame) {
     
    634637        lavc_param_rc_max_rate = 2516;
    635638        lavc_param_rc_buffer_size = 224 * 8;
    636639        lavc_param_rc_buffer_aggressivity = 99;
    637         lavc_param_scan_offset = CODEC_FLAG_SVCD_SCAN_OFFSET;
     640        lavc_param_scan_offset = 1;
    638641
    639642        break;
    640643
     
    674677
    675678        lavc_param_rc_buffer_size = 224 * 8;
    676679        lavc_param_rc_buffer_aggressivity = 99;
    677         lavc_param_scan_offset = CODEC_FLAG_SVCD_SCAN_OFFSET;
     680        lavc_param_scan_offset = 1;
    678681
    679682        break;
    680683
     
    838841    lavc_venc_context->rc_strategy        = lavc_param_vrc_strategy;
    839842    lavc_venc_context->b_frame_strategy   = lavc_param_vb_strategy;
    840843    lavc_venc_context->b_quant_offset     = lavc_param_vb_qoffset;
    841     lavc_venc_context->luma_elim_threshold= lavc_param_luma_elim_threshold;
    842     lavc_venc_context->chroma_elim_threshold= lavc_param_chroma_elim_threshold;
     844
     845    char buf[1024];
     846#define set_dict_opt(val, opt) \
     847        snprintf(buf, sizeof(buf), "%i", val); \
     848        av_dict_set(&lavc_venc_opts, opt, buf, 0)
     849    set_dict_opt(lavc_param_luma_elim_threshold, "luma_elim_threshold");
     850    set_dict_opt(lavc_param_chroma_elim_threshold, "chroma_elim_threshold");
    843851    lavc_venc_context->rtp_payload_size   = lavc_param_packet_size;
    844852#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)   
    845853    if (lavc_param_packet_size)
     
    870878    lavc_venc_context->context_model      = lavc_param_context;
    871879    lavc_venc_context->scenechange_threshold= lavc_param_sc_threshold;
    872880    lavc_venc_context->noise_reduction    = lavc_param_noise_reduction;
    873     lavc_venc_context->inter_threshold    = lavc_param_inter_threshold;
     881    set_dict_opt(lavc_param_inter_threshold, "inter_threshold");
    874882    lavc_venc_context->intra_dc_precision = lavc_param_intra_dc_precision;
    875883    lavc_venc_context->skip_top           = lavc_param_skip_top;
    876884    lavc_venc_context->skip_bottom        = lavc_param_skip_bottom;
     
    887895                    lavc_venc_context->thread_count);
    888896    }
    889897
    890     avcodec_thread_init(lavc_venc_context, lavc_param_threads);
     898    lavc_venc_context->thread_count = lavc_param_threads;
    891899
    892900    if (lavc_param_intra_matrix) {
    893901        char *tmp;
     
    10611069    lavc_venc_context->ildct_cmp  = lavc_param_ildct_cmp;
    10621070    lavc_venc_context->dia_size   = lavc_param_dia_size;
    10631071    lavc_venc_context->flags |= lavc_param_qpel;
    1064     lavc_venc_context->flags |= lavc_param_gmc;
     1072    if(lavc_param_gmc)
     1073        av_dict_set(&lavc_venc_opts, "gmc", "1", 0);
    10651074    lavc_venc_context->flags |= lavc_param_closedgop;
    10661075    lavc_venc_context->flags |= lavc_param_trunc;
    10671076    lavc_venc_context->flags |= lavc_param_aic;
    1068     lavc_venc_context->flags |= lavc_param_umv;
    10691077    lavc_venc_context->flags |= lavc_param_v4mv;
    1070     lavc_venc_context->flags |= lavc_param_data_partitioning;
    1071     lavc_venc_context->flags |= lavc_param_cbp;
    1072     lavc_venc_context->flags |= lavc_param_mv0;
    1073     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;
     1078    if(lavc_param_cbp)
     1079        av_dict_set(&lavc_venc_opts, "mpv_flags", "+cbp_rd", 0);
     1080    if(lavc_param_mv0)
     1081        av_dict_set(&lavc_venc_opts, "mpv_flags", "+mv0", 0);
     1082    if(lavc_param_qp_rd)
     1083        av_dict_set(&lavc_venc_opts, "mpv_flags", "+qp_rd", 0);
    10771084    lavc_venc_context->flags |= lavc_param_ilme;
    10781085#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)   
    10791086    lavc_venc_context->flags |= lavc_param_trell;
     
    10841091    if (lavc_param_gray)
    10851092        lavc_venc_context->flags |= CODEC_FLAG_GRAY;
    10861093    if (lavc_param_normalize_aqp)
    1087         lavc_venc_context->flags |= CODEC_FLAG_NORMALIZE_AQP;
     1094        av_dict_set(&lavc_venc_opts, "mpv_flags", "+naq", 0);
    10881095
    10891096    switch(vob->encode_fields) {
    10901097    case TC_ENCODE_FIELDS_TOP_FIRST:
     
    11121119    lavc_venc_context->prediction_method = lavc_param_prediction_method;
    11131120
    11141121    if(is_huffyuv)
    1115         lavc_venc_context->pix_fmt = PIX_FMT_YUV422P;
     1122        lavc_venc_context->pix_fmt = AV_PIX_FMT_YUV422P;
    11161123    else
    11171124    {
    11181125        switch(pix_fmt)
     
    11211128            case CODEC_RGB:
    11221129            {
    11231130                if(is_mjpeg)
    1124                     lavc_venc_context->pix_fmt = PIX_FMT_YUVJ420P;
     1131                    lavc_venc_context->pix_fmt = AV_PIX_FMT_YUVJ420P;
    11251132                else
    1126                     lavc_venc_context->pix_fmt = PIX_FMT_YUV420P;
     1133                    lavc_venc_context->pix_fmt = AV_PIX_FMT_YUV420P;
    11271134                break;
    11281135            }
    11291136
    11301137            case CODEC_YUV422:
    11311138            {
    11321139                if(is_mjpeg)
    1133                     lavc_venc_context->pix_fmt = PIX_FMT_YUVJ422P;
     1140                    lavc_venc_context->pix_fmt = AV_PIX_FMT_YUVJ422P;
    11341141                else
    1135                     lavc_venc_context->pix_fmt = PIX_FMT_YUV422P;
     1142                    lavc_venc_context->pix_fmt = AV_PIX_FMT_YUV422P;
    11361143                break;
    11371144            }
    11381145
     
    12031210
    12041211    lavc_venc_context->me_method = ME_ZERO + lavc_param_vme;
    12051212
    1206 
    12071213        /* FIXME: transcode itself contains "broken ffmpeg default settings", thus we need to override them! */
    1208         if (lavc_param_video_preset) {
     1214        if (lavc_param_video_preset && strcmp(lavc_param_video_preset, "none")) {
    12091215                avcodec_opts[AVMEDIA_TYPE_VIDEO] = lavc_venc_context;
    12101216                video_codec_name = ffmpeg_codec_name(codec->name);
    12111217
     
    12411247                }
    12421248        }
    12431249
     1250    if (lavc_param_scan_offset) {
     1251      av_dict_set(&lavc_venc_opts, "scan_offset", "1", 0);
     1252    }
     1253
     1254    if (lavc_param_ss) {
     1255      av_dict_set(&lavc_venc_opts, "structured_slices", "1", 0);
     1256    }
     1257
     1258    if (lavc_param_alt) {
     1259      av_dict_set(&lavc_venc_opts, "alternate_scan", "1", 0);
     1260    }
     1261
     1262    if (lavc_param_umv) {
     1263      av_dict_set(&lavc_venc_opts, "umv", "1", 0);
     1264    }
     1265
     1266    if (lavc_param_data_partitioning) {
     1267      av_dict_set(&lavc_venc_opts, "vdpart", "1", 0);
     1268    }
    12441269
    12451270    //-- open codec --
    12461271    //----------------
    12471272    TC_LOCK_LIBAVCODEC;
    1248     ret = avcodec_open(lavc_venc_context, lavc_venc_codec);
     1273    ret = avcodec_open2(lavc_venc_context, lavc_venc_codec, &lavc_venc_opts);
    12491274    TC_UNLOCK_LIBAVCODEC;
    12501275    if (ret < 0) {
    12511276      tc_log_warn(MOD_NAME, "could not open FFMPEG codec");
    12521277      return TC_EXPORT_ERROR;
    12531278    }
    12541279
    1255     if (lavc_venc_context->codec->encode == NULL) {
     1280    if (av_codec_is_encoder(lavc_venc_context->codec) == 0) {
    12561281      tc_log_warn(MOD_NAME, "could not open FFMPEG codec "
    1257               "(lavc_venc_context->codec->encode == NULL)");
     1282              "(av_codec_is_encoder(lavc_venc_context->codec) == 0)");
    12581283      return TC_EXPORT_ERROR;
    12591284    }
    12601285
     
    15741599
    15751600  int out_size;
    15761601  const char pict_type_char[5]= {'?', 'I', 'P', 'B', 'S'};
     1602  AVPacket pkt;
     1603  int ret, got_packet = 0;
    15771604
    15781605  if (param->flag == TC_VIDEO) {
    15791606
     
    15981625                        YUV_INIT_PLANES(src, param->buffer, IMG_YUV_DEFAULT,
    15991626                                                lavc_venc_context->width, lavc_venc_context->height);
    16001627                avpicture_fill((AVPicture *)lavc_venc_frame, img_buffer,
    1601                                PIX_FMT_YUV422P, lavc_venc_context->width,
     1628                               AV_PIX_FMT_YUV422P, lavc_venc_context->width,
    16021629                               lavc_venc_context->height);
    16031630                        /* FIXME: can't use tcv_convert (see decode_lavc.c) */
    16041631                ac_imgconvert(src, IMG_YUV_DEFAULT,
     
    16281655                                                lavc_venc_context->width,
    16291656                                lavc_venc_context->height);
    16301657                avpicture_fill((AVPicture *)lavc_venc_frame, img_buffer,
    1631                                PIX_FMT_YUV420P, lavc_venc_context->width,
     1658                               AV_PIX_FMT_YUV420P, lavc_venc_context->width,
    16321659                               lavc_venc_context->height);
    16331660                ac_imgconvert(src, IMG_YUV422P,
    16341661                              lavc_venc_frame->data, IMG_YUV420P,
     
    16391666
    16401667        case CODEC_RGB:
    16411668            avpicture_fill((AVPicture *)lavc_venc_frame, img_buffer,
    1642                            PIX_FMT_YUV420P, lavc_venc_context->width,
     1669                           AV_PIX_FMT_YUV420P, lavc_venc_context->width,
    16431670                           lavc_venc_context->height);
    16441671            ac_imgconvert(&param->buffer, IMG_RGB_DEFAULT,
    16451672                              lavc_venc_frame->data, IMG_YUV420P,
     
    16521679              return TC_EXPORT_ERROR;
    16531680    }
    16541681
     1682    av_init_packet(&pkt);
     1683    pkt.data = enc_buffer;
     1684    pkt.size = size;
    16551685
    16561686    TC_LOCK_LIBAVCODEC;
    1657     out_size = avcodec_encode_video(lavc_venc_context,
    1658                                     enc_buffer, size,
    1659                                     lavc_venc_frame);
     1687    ret = avcodec_encode_video2(lavc_venc_context, &pkt,
     1688                                    lavc_venc_frame, &got_packet);
    16601689    TC_UNLOCK_LIBAVCODEC;
    16611690
     1691    out_size = ret ? ret : pkt.size;
     1692
    16621693    if (out_size < 0) {
    16631694      tc_log_warn(MOD_NAME, "encoder error: size (%d)", out_size);
    16641695      return TC_EXPORT_ERROR;
  • export/ffmpeg_cfg.c

    a b  
    3434//int lavc_param_vqscale = 0;
    3535//int lavc_param_vqmin = 2;
    3636//int lavc_param_vqmax = 31;
    37 int lavc_param_mb_qmin = 2;
    38 int lavc_param_mb_qmax = 31;
    3937int lavc_param_lmin = 2;
    4038int lavc_param_lmax = 31;
    4139int lavc_param_vqdiff = 3;
     
    126124//int lavc_param_atag = 0;
    127125//int lavc_param_abitrate = 224;
    128126
    129 char *lavc_param_video_preset = "medium";
     127char *lavc_param_video_preset = "none";
    130128char *lavc_param_ffmpeg_datadir = "/usr/share/ffmpeg";
    131129
    132130TCConfigEntry lavcopts_conf[]={
     
    143141//    {"vqscale", &lavc_param_vqscale, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 31},
    144142//    {"vqmin", &lavc_param_vqmin, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 31},
    145143//    {"vqmax", &lavc_param_vqmax, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 31},
    146     {"mbqmin", &lavc_param_mb_qmin, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 31},
    147     {"mbqmax", &lavc_param_mb_qmax, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 31},
    148144    {"lmin", &lavc_param_lmin, TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.01, 255.0},
    149145    {"lmax", &lavc_param_lmax, TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.01, 255.0},
    150146    {"vqdiff", &lavc_param_vqdiff, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 31},
    151147    {"vqcomp", &lavc_param_vqcompress, TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 1.0},
    152148    {"vqblur", &lavc_param_vqblur, TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 1.0},
    153149    {"vb_qfactor", &lavc_param_vb_qfactor, TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, -31.0, 31.0},
    154     {"vmax_b_frames", &lavc_param_vmax_b_frames, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, FF_MAX_B_FRAMES},
     150    {"vmax_b_frames", &lavc_param_vmax_b_frames, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, INT_MAX},
    155151//    {"vpass", &lavc_param_vpass, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 2},
    156152    {"vrc_strategy", &lavc_param_vrc_strategy, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 2},
    157153    {"vb_strategy", &lavc_param_vb_strategy, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 10},
     
    160156    {"vcelim", &lavc_param_chroma_elim_threshold, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -99, 99},
    161157    {"vpsize", &lavc_param_packet_size, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 100000000},
    162158    {"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},
     159    {"vdpart", &lavc_param_data_partitioning, TCCONF_TYPE_FLAG, 0, 0, 1},
    164160//    {"keyint", &lavc_param_keyint, TCCONF_TYPE_INT, 0, 0, 0},
    165     {"gray", &lavc_param_gray, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_PART},
     161    {"gray", &lavc_param_gray, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_GRAY},
    166162    {"mpeg_quant", &lavc_param_mpeg_quant, TCCONF_TYPE_FLAG, 0, 0, 1},
    167163    {"vi_qfactor", &lavc_param_vi_qfactor, TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, -31.0, 31.0},
    168164    {"vi_qoffset", &lavc_param_vi_qoffset, TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 31.0},
     
    211207#else
    212208    {"aic", &lavc_param_aic, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_AC_PRED},
    213209#endif   
    214     {"umv", &lavc_param_umv, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_H263P_UMV},
     210    {"umv", &lavc_param_umv, TCCONF_TYPE_FLAG, 0, 0, 1},
    215211    {"ibias", &lavc_param_ibias, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -512, 512},
    216212    {"pbias", &lavc_param_pbias, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -512, 512},
    217213    {"coder", &lavc_param_coder, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 10},
    218214    {"context", &lavc_param_context, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 10},
    219215    {"intra_matrix", &lavc_param_intra_matrix, TCCONF_TYPE_STRING, 0, 0, 0},
    220216    {"inter_matrix", &lavc_param_inter_matrix, TCCONF_TYPE_STRING, 0, 0, 0},
    221     {"cbp", &lavc_param_cbp, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_CBP_RD},
    222     {"mv0", &lavc_param_mv0, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_MV0},
     217    {"cbp", &lavc_param_cbp, TCCONF_TYPE_FLAG, 0, 0, 1},
     218    {"mv0", &lavc_param_mv0, TCCONF_TYPE_FLAG, 0, 0, 1},
    223219    {"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},
     220    {"qprd", &lavc_param_qp_rd, TCCONF_TYPE_FLAG, 0, 0, 1},
    225221    {"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},
    227     {"svcd_sof", &lavc_param_scan_offset, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_SVCD_SCAN_OFFSET},
    228     {"alt", &lavc_param_alt, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_ALT_SCAN},
     222    {"ss", &lavc_param_ss, TCCONF_TYPE_FLAG, 0, 0, 1},
     223    {"svcd_sof", &lavc_param_scan_offset, TCCONF_TYPE_FLAG, 0, 0, 1},
     224    {"alt", &lavc_param_alt, TCCONF_TYPE_FLAG, 0, 0, 1},
    229225    {"ilme", &lavc_param_ilme, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_INTERLACED_ME},
    230226    {"inter_threshold", &lavc_param_inter_threshold, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -1000000, 1000000},
    231227    {"sc_threshold", &lavc_param_sc_threshold, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -1000000, 1000000},
    232228    {"top", &lavc_param_top, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -1, 1},
    233     {"gmc", &lavc_param_gmc, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_GMC},
     229    {"gmc", &lavc_param_gmc, TCCONF_TYPE_FLAG, 0, 0, 1},
    234230    {"trunc", &lavc_param_trunc, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_TRUNCATED},
    235231    {"closedgop", &lavc_param_closedgop, TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_CLOSED_GOP},
    236232    {"intra_dc_precision", &lavc_param_intra_dc_precision, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 16},
  • export/ffmpeg_cfg.h

    a b  
    1313//extern int lavc_param_vqscale;
    1414//extern int lavc_param_vqmin;
    1515//extern int lavc_param_vqmax;
    16 extern int lavc_param_mb_qmin;
    17 extern int lavc_param_mb_qmax;
    1816extern int lavc_param_lmin;
    1917extern int lavc_param_lmax;
    2018extern int lavc_param_vqdiff;
  • filter/filter_pp.c

    a b  
    3838
    3939/* FIXME: these use the filter ID as an index--the ID can grow
    4040 * arbitrarily large, so this needs to be fixed */
    41 static pp_mode_t *mode[100];
    42 static pp_context_t *context[100];
     41static pp_mode *mode[100];
     42static pp_context *context[100];
    4343static int width[100], height[100];
    4444static int pre[100];
    4545
  • import/decode_lavc.c

    a b  
    5858
    5959// fourCC to ID mapping taken from MPlayer's codecs.conf
    6060static struct ffmpeg_codec ffmpeg_codecs[] = {
    61   {CODEC_ID_MSMPEG4V1, TC_CODEC_ERROR, "mp41",
     61  {AV_CODEC_ID_MSMPEG4V1, TC_CODEC_ERROR, "mp41",
    6262    {"MP41", "DIV1", ""}},
    63   {CODEC_ID_MSMPEG4V2, TC_CODEC_MP42, "mp42",
     63  {AV_CODEC_ID_MSMPEG4V2, TC_CODEC_MP42, "mp42",
    6464    {"MP42", "DIV2", ""}},
    65   {CODEC_ID_MSMPEG4V3, TC_CODEC_DIVX3, "msmpeg4",
     65  {AV_CODEC_ID_MSMPEG4V3, TC_CODEC_DIVX3, "msmpeg4",
    6666    {"DIV3", "DIV5", "AP41", "MPG3", "MP43", ""}},
    67   {CODEC_ID_MPEG4, TC_CODEC_DIVX4, "mpeg4",
     67  {AV_CODEC_ID_MPEG4, TC_CODEC_DIVX4, "mpeg4",
    6868    {"DIVX", "XVID", "MP4S", "M4S2", "MP4V", "UMP4", "DX50", ""}},
    69   {CODEC_ID_MJPEG, TC_CODEC_MJPEG, "mjpeg",
     69  {AV_CODEC_ID_MJPEG, TC_CODEC_MJPEG, "mjpeg",
    7070    {"MJPG", "AVRN", "AVDJ", "JPEG", "MJPA", "JFIF", ""}},
    71   {CODEC_ID_MPEG1VIDEO, TC_CODEC_MPEG1VIDEO, "mpeg1video",
     71  {AV_CODEC_ID_MPEG1VIDEO, TC_CODEC_MPEG1VIDEO, "mpeg1video",
    7272    {"MPG1", ""}},
    73   {CODEC_ID_DVVIDEO, TC_CODEC_DV, "dvvideo",
     73  {AV_CODEC_ID_DVVIDEO, TC_CODEC_DV, "dvvideo",
    7474    {"DVSD", ""}},
    75   {CODEC_ID_WMV1, TC_CODEC_WMV1, "wmv1",
     75  {AV_CODEC_ID_WMV1, TC_CODEC_WMV1, "wmv1",
    7676    {"WMV1", ""}},
    77   {CODEC_ID_WMV2, TC_CODEC_WMV2, "wmv2",
     77  {AV_CODEC_ID_WMV2, TC_CODEC_WMV2, "wmv2",
    7878    {"WMV2", ""}},
    79   {CODEC_ID_HUFFYUV, TC_CODEC_HUFFYUV, "hfyu",
     79  {AV_CODEC_ID_HUFFYUV, TC_CODEC_HUFFYUV, "hfyu",
    8080    {"HFYU", ""}},
    81   {CODEC_ID_H263I, TC_CODEC_H263I, "h263i",
     81  {AV_CODEC_ID_H263I, TC_CODEC_H263I, "h263i",
    8282    {"I263", ""}},
    83   {CODEC_ID_H263P, TC_CODEC_H263P, "h263p",
     83  {AV_CODEC_ID_H263P, TC_CODEC_H263P, "h263p",
    8484    {"H263", "U263", "VIV1", ""}},
    85   {CODEC_ID_RV10, TC_CODEC_RV10, "rv10",
     85  {AV_CODEC_ID_RV10, TC_CODEC_RV10, "rv10",
    8686    {"RV10", "RV13", ""}},
    87   {CODEC_ID_SVQ1, TC_CODEC_SVQ1, "svq1",
     87  {AV_CODEC_ID_SVQ1, TC_CODEC_SVQ1, "svq1",
    8888    {"SVQ1", ""}},
    89   {CODEC_ID_SVQ3, TC_CODEC_SVQ3, "svq3",
     89  {AV_CODEC_ID_SVQ3, TC_CODEC_SVQ3, "svq3",
    9090    {"SVQ3", ""}},
    91   {CODEC_ID_MPEG2VIDEO, TC_CODEC_MPEG2, "mpeg2video",
     91  {AV_CODEC_ID_MPEG2VIDEO, TC_CODEC_MPEG2, "mpeg2video",
    9292    {"MPG2", ""}},
    9393  {0, TC_CODEC_UNKNOWN, NULL, {""}}};
    9494
     
    170170
    171171  // Set these to the expected values so that ffmpeg's decoder can
    172172  // properly detect interlaced input.
    173   lavc_dec_context = avcodec_alloc_context();
     173  lavc_dec_context = avcodec_alloc_context3(NULL);
    174174  if (lavc_dec_context == NULL) {
    175175      tc_log_error(__FILE__, "Could not allocate enough memory.");
    176176      goto decoder_error;
     
    181181#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
    182182  lavc_dec_context->error_resilience  = 2;
    183183#else
    184   lavc_dec_context->error_recognition = 2;
     184  lavc_dec_context->err_recognition = 2;
    185185#endif
    186186  lavc_dec_context->error_concealment = 3;
    187187  lavc_dec_context->workaround_bugs = FF_BUG_AUTODETECT;
    188188
    189   if (avcodec_open(lavc_dec_context, lavc_dec_codec) < 0) {
     189  if (avcodec_open2(lavc_dec_context, lavc_dec_codec, NULL) < 0) {
    190190      tc_log_error(__FILE__, "Could not initialize the '%s' codec.",
    191191                   codec->name);
    192192      goto decoder_error;
     
    290290
    291291      // Convert avcodec image to the requested YUV or RGB format
    292292      switch (lavc_dec_context->pix_fmt) {
    293         case PIX_FMT_YUVJ420P:
    294         case PIX_FMT_YUV420P:
     293        case AV_PIX_FMT_YUVJ420P:
     294        case AV_PIX_FMT_YUV420P:
    295295            // Remove "dead space" at right edge of planes, if any
    296296            if (picture.linesize[0] != lavc_dec_context->width) {
    297297                int y;
     
    315315                          pix_fmt==TC_CODEC_YUV420P ? IMG_YUV420P : IMG_RGB_DEFAULT,
    316316                          lavc_dec_context->width, lavc_dec_context->height);
    317317            break;
    318         case PIX_FMT_YUV411P:
     318        case AV_PIX_FMT_YUV411P:
    319319            if (picture.linesize[0] != lavc_dec_context->width) {
    320320                int y;
    321321                for (y = 0; y < lavc_dec_context->height; y++) {
     
    334334                          pix_fmt==TC_CODEC_YUV420P ? IMG_YUV420P : IMG_RGB_DEFAULT,
    335335                          lavc_dec_context->width, lavc_dec_context->height);
    336336            break;
    337         case PIX_FMT_YUVJ422P:
    338         case PIX_FMT_YUV422P:
     337        case AV_PIX_FMT_YUVJ422P:
     338        case AV_PIX_FMT_YUV422P:
    339339            if (picture.linesize[0] != lavc_dec_context->width) {
    340340                int y;
    341341                for (y = 0; y < lavc_dec_context->height; y++) {
     
    354354                          pix_fmt==TC_CODEC_YUV420P ? IMG_YUV420P : IMG_RGB_DEFAULT,
    355355                          lavc_dec_context->width, lavc_dec_context->height);
    356356            break;
    357         case PIX_FMT_YUVJ444P:
    358         case PIX_FMT_YUV444P:
     357        case AV_PIX_FMT_YUVJ444P:
     358        case AV_PIX_FMT_YUV444P:
    359359            if (picture.linesize[0] != lavc_dec_context->width) {
    360360                int y;
    361361                for (y = 0; y < lavc_dec_context->height; y++) {
  • import/import_ffmpeg.c

    a b  
    5959
    6060// fourCC to ID mapping taken from MPlayer's codecs.conf
    6161static struct ffmpeg_codec ffmpeg_codecs[] = {
    62   {CODEC_ID_MSMPEG4V1, TC_CODEC_ERROR, "mp41",
     62  {AV_CODEC_ID_MSMPEG4V1, TC_CODEC_ERROR, "mp41",
    6363    {"MP41", "DIV1", ""}},
    64   {CODEC_ID_MSMPEG4V2, TC_CODEC_MP42, "mp42",
     64  {AV_CODEC_ID_MSMPEG4V2, TC_CODEC_MP42, "mp42",
    6565    {"MP42", "DIV2", ""}},
    66   {CODEC_ID_MSMPEG4V3, TC_CODEC_DIVX3, "msmpeg4",
     66  {AV_CODEC_ID_MSMPEG4V3, TC_CODEC_DIVX3, "msmpeg4",
    6767    {"DIV3", "DIV5", "AP41", "MPG3", "MP43", ""}},
    68   {CODEC_ID_MPEG4, TC_CODEC_DIVX4, "mpeg4",
     68  {AV_CODEC_ID_MPEG4, TC_CODEC_DIVX4, "mpeg4",
    6969    {"DIVX", "XVID", "MP4S", "M4S2", "MP4V", "UMP4", "DX50", ""}},
    70   {CODEC_ID_MJPEG, TC_CODEC_MJPEG, "mjpeg",
     70  {AV_CODEC_ID_MJPEG, TC_CODEC_MJPEG, "mjpeg",
    7171    {"MJPG", "AVRN", "AVDJ", "JPEG", "MJPA", "JFIF", ""}},
    72   {CODEC_ID_MPEG1VIDEO, TC_CODEC_MPG1, "mpeg1video",
     72  {AV_CODEC_ID_MPEG1VIDEO, TC_CODEC_MPG1, "mpeg1video",
    7373    {"MPG1", ""}},
    74   {CODEC_ID_DVVIDEO, TC_CODEC_DV, "dvvideo",
     74  {AV_CODEC_ID_DVVIDEO, TC_CODEC_DV, "dvvideo",
    7575    {"DVSD", ""}},
    76   {CODEC_ID_WMV1, TC_CODEC_WMV1, "wmv1",
     76  {AV_CODEC_ID_WMV1, TC_CODEC_WMV1, "wmv1",
    7777    {"WMV1", ""}},
    78   {CODEC_ID_WMV2, TC_CODEC_WMV2, "wmv2",
     78  {AV_CODEC_ID_WMV2, TC_CODEC_WMV2, "wmv2",
    7979    {"WMV2", ""}},
    80   {CODEC_ID_HUFFYUV, TC_CODEC_HUFFYUV, "hfyu",
     80  {AV_CODEC_ID_HUFFYUV, TC_CODEC_HUFFYUV, "hfyu",
    8181    {"HFYU", ""}},
    82   {CODEC_ID_H263I, TC_CODEC_H263I, "h263i",
     82  {AV_CODEC_ID_H263I, TC_CODEC_H263I, "h263i",
    8383    {"I263", ""}},
    84   {CODEC_ID_H263P, TC_CODEC_H263P, "h263p",
     84  {AV_CODEC_ID_H263P, TC_CODEC_H263P, "h263p",
    8585    {"H263", "U263", "VIV1", ""}},
    86   {CODEC_ID_H264, TC_CODEC_H264, "h264",
     86  {AV_CODEC_ID_H264, TC_CODEC_H264, "h264",
    8787    {"H264", "h264", "X264", "x264", "avc1", ""}},
    88   {CODEC_ID_RV10, TC_CODEC_RV10, "rv10",
     88  {AV_CODEC_ID_RV10, TC_CODEC_RV10, "rv10",
    8989    {"RV10", "RV13", ""}},
    90   {CODEC_ID_SVQ1, TC_CODEC_SVQ1, "svq1",
     90  {AV_CODEC_ID_SVQ1, TC_CODEC_SVQ1, "svq1",
    9191    {"SVQ1", ""}},
    92   {CODEC_ID_SVQ3, TC_CODEC_SVQ3, "svq3",
     92  {AV_CODEC_ID_SVQ3, TC_CODEC_SVQ3, "svq3",
    9393    {"SVQ3", ""}},
    94   {CODEC_ID_MPEG2VIDEO, TC_CODEC_MPEG2, "mpeg2video",
     94  {AV_CODEC_ID_MPEG2VIDEO, TC_CODEC_MPEG2, "mpeg2video",
    9595    {"MPG2", ""}},
    96   {CODEC_ID_MPEG2VIDEO, TC_CODEC_MPEG, "mpeg2video",
     96  {AV_CODEC_ID_MPEG2VIDEO, TC_CODEC_MPEG, "mpeg2video",
    9797    {"MPG2", ""}},
    98   {CODEC_ID_ASV1, TC_CODEC_ASV1, "asv1",
     98  {AV_CODEC_ID_ASV1, TC_CODEC_ASV1, "asv1",
    9999    {"ASV1", ""}},
    100   {CODEC_ID_ASV2, TC_CODEC_ASV2, "asv2",
     100  {AV_CODEC_ID_ASV2, TC_CODEC_ASV2, "asv2",
    101101    {"ASV2", ""}},
    102   {CODEC_ID_FFV1, TC_CODEC_FFV1, "ffv1",
     102  {AV_CODEC_ID_FFV1, TC_CODEC_FFV1, "ffv1",
    103103    {"FFV1", ""}},
    104   {CODEC_ID_RAWVIDEO, TC_CODEC_YUV420P, "raw",
     104  {AV_CODEC_ID_RAWVIDEO, TC_CODEC_YUV420P, "raw",
    105105    {"I420", "IYUV", ""}},
    106   {CODEC_ID_RAWVIDEO, TC_CODEC_YUV422P, "raw",
     106  {AV_CODEC_ID_RAWVIDEO, TC_CODEC_YUV422P, "raw",
    107107    {"Y42B", ""}},
    108108  {0, TC_CODEC_UNKNOWN, NULL, {""}}};
    109109
     
    302302
    303303    // Set these to the expected values so that ffmpeg's decoder can
    304304    // properly detect interlaced input.
    305     lavc_dec_context = avcodec_alloc_context();
     305    lavc_dec_context = avcodec_alloc_context3(lavc_dec_codec);
    306306    if (lavc_dec_context == NULL) {
    307307      tc_log_error(MOD_NAME, "Could not allocate enough memory.");
    308308      return TC_IMPORT_ERROR;
     
    314314#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
    315315    lavc_dec_context->error_resilience  = 2;
    316316#else
    317     lavc_dec_context->error_recognition = 2;
     317    lavc_dec_context->err_recognition = 2;
    318318#endif
    319319    lavc_dec_context->error_concealment = 3;
    320320    lavc_dec_context->workaround_bugs = FF_BUG_AUTODETECT;
     
    324324    // XXX: some codecs need extra data
    325325    switch (codec->id)
    326326    {
    327       case CODEC_ID_MJPEG: extra_data_size  = 28; break;
    328       case CODEC_ID_LJPEG: extra_data_size  = 28; break;
    329       case CODEC_ID_HUFFYUV: extra_data_size = 1000; break;
    330       case CODEC_ID_ASV1: extra_data_size = 8; break;
    331       case CODEC_ID_ASV2: extra_data_size = 8; break;
    332       case CODEC_ID_WMV1: extra_data_size = 4; break;
    333       case CODEC_ID_WMV2: extra_data_size = 4; break;
     327      case AV_CODEC_ID_MJPEG: extra_data_size  = 28; break;
     328      case AV_CODEC_ID_LJPEG: extra_data_size  = 28; break;
     329      case AV_CODEC_ID_HUFFYUV: extra_data_size = 1000; break;
     330      case AV_CODEC_ID_ASV1: extra_data_size = 8; break;
     331      case AV_CODEC_ID_ASV2: extra_data_size = 8; break;
     332      case AV_CODEC_ID_WMV1: extra_data_size = 4; break;
     333      case AV_CODEC_ID_WMV2: extra_data_size = 4; break;
    334334      default: extra_data_size = 0; break;
    335335    }
    336336
     
    344344    }
    345345
    346346    TC_LOCK_LIBAVCODEC;
    347     ret = avcodec_open(lavc_dec_context, lavc_dec_codec);
     347    ret = avcodec_open2(lavc_dec_context, lavc_dec_codec, NULL);
    348348    TC_UNLOCK_LIBAVCODEC;
    349349    if (ret < 0) {
    350350      tc_log_warn(MOD_NAME, "Could not initialize the '%s' codec.",
     
    360360        frame_size = x_dim*y_dim + 2*UV_PLANE_SIZE(IMG_YUV_DEFAULT,x_dim,y_dim);
    361361
    362362        // we adapt the color space
    363         if(codec->id == CODEC_ID_MJPEG) {
     363        if(codec->id == AV_CODEC_ID_MJPEG) {
    364364          enable_levels_filter();
    365365        }
    366366        break;
     
    434434      }
    435435
    436436      // we adapt the color space
    437       if(codec->id == CODEC_ID_MJPEG) {
     437      if(codec->id == AV_CODEC_ID_MJPEG) {
    438438        enable_levels_filter();
    439439      }
    440440
     
    504504      int bkey = 0;
    505505
    506506      // check for keyframes
    507       if (codec->id == CODEC_ID_MSMPEG4V3) {
     507      if (codec->id == AV_CODEC_ID_MSMPEG4V3) {
    508508        if (divx3_is_key(buffer)) bkey = 1;
    509509      }
    510       else if (codec->id == CODEC_ID_MPEG4) {
     510      else if (codec->id == AV_CODEC_ID_MPEG4) {
    511511        if (mpeg4_is_key(buffer, bytes_read)) bkey = 1;
    512512      }
    513       else if (codec->id == CODEC_ID_MJPEG) {
     513      else if (codec->id == AV_CODEC_ID_MJPEG) {
    514514        bkey = 1;
    515515      }
    516516
     
    580580
    581581    // Convert avcodec image to our internal YUV or RGB format
    582582    switch (lavc_dec_context->pix_fmt) {
    583       case PIX_FMT_YUVJ420P:
    584       case PIX_FMT_YUV420P:
     583      case AV_PIX_FMT_YUVJ420P:
     584      case AV_PIX_FMT_YUV420P:
    585585        src_fmt = IMG_YUV420P;
    586586        YUV_INIT_PLANES(src_planes, frame, src_fmt,
    587587                        lavc_dec_context->width, lavc_dec_context->height);
     
    612612        }
    613613        break;
    614614
    615       case PIX_FMT_YUV411P:
     615      case AV_PIX_FMT_YUV411P:
    616616        src_fmt = IMG_YUV411P;
    617617        YUV_INIT_PLANES(src_planes, frame, src_fmt,
    618618                        lavc_dec_context->width, lavc_dec_context->height);
     
    640640        }
    641641        break;
    642642
    643       case PIX_FMT_YUVJ422P:
    644       case PIX_FMT_YUV422P:
     643      case AV_PIX_FMT_YUVJ422P:
     644      case AV_PIX_FMT_YUV422P:
    645645        src_fmt = IMG_YUV422P;
    646646        YUV_INIT_PLANES(src_planes, frame, src_fmt,
    647647                        lavc_dec_context->width, lavc_dec_context->height);
     
    669669        }
    670670        break;
    671671
    672       case PIX_FMT_YUVJ444P:
    673       case PIX_FMT_YUV444P:
     672      case AV_PIX_FMT_YUVJ444P:
     673      case AV_PIX_FMT_YUV444P:
    674674        src_fmt = IMG_YUV444P;
    675675        YUV_INIT_PLANES(src_planes, frame, src_fmt,
    676676                        lavc_dec_context->width, lavc_dec_context->height);
  • import/probe_ffmpeg.c

    a b  
    9999
    100100    TC_INIT_LIBAVCODEC;
    101101
    102     ret = av_open_input_file(&lavf_dmx_context, ipipe->name,
    103                              NULL, 0, NULL);
     102    ret = avformat_open_input(&lavf_dmx_context, ipipe->name,
     103                             NULL, NULL);
    104104    if (ret != 0) {
    105105        tc_log_error(__FILE__, "unable to open '%s'"
    106106                               " (libavformat failure)",
     
    109109        return;
    110110    }
    111111
    112     ret = av_find_stream_info(lavf_dmx_context);
     112    ret = avformat_find_stream_info(lavf_dmx_context, NULL);
    113113    if (ret < 0) {
    114114        tc_log_error(__FILE__, "unable to fetch informations from '%s'"
    115115                               " (libavformat failure)",
     
    120120
    121121    translate_info(lavf_dmx_context, ipipe->probe_info);
    122122
     123#if LIBAVFORMAT_VERSION_INT > AV_VERSION_INT(53,25,0)
     124    avformat_close_input(&lavf_dmx_context);
     125#else
    123126    av_close_input_file(lavf_dmx_context);
     127#endif
    124128    return;
    125129}
    126130
  • libtc/tcavcodec.h

    a b  
    5353
    5454#define TC_INIT_LIBAVCODEC do { \
    5555    TC_LOCK_LIBAVCODEC; \
    56     avcodec_init(); \
    5756    avcodec_register_all(); \
    5857    TC_UNLOCK_LIBAVCODEC; \
    5958} while (0)