Revision: 79905 http://trac.macports.org/changeset/79905 Author: jeremyhu@macports.org Date: 2011-06-29 00:41:42 -0700 (Wed, 29 Jun 2011) Log Message: ----------- multimedia: Revision bumps to force rebuild against new x264 Modified Paths: -------------- trunk/dports/multimedia/MPlayer/Portfile trunk/dports/multimedia/VLC/Portfile trunk/dports/multimedia/VLC09/Portfile trunk/dports/multimedia/avidemux/Portfile trunk/dports/multimedia/ffmpeg/Portfile trunk/dports/multimedia/transcode/Portfile Added Paths: ----------- trunk/dports/multimedia/avidemux/files/patch-x264.diff Modified: trunk/dports/multimedia/MPlayer/Portfile =================================================================== --- trunk/dports/multimedia/MPlayer/Portfile 2011-06-29 07:40:52 UTC (rev 79904) +++ trunk/dports/multimedia/MPlayer/Portfile 2011-06-29 07:41:42 UTC (rev 79905) @@ -6,6 +6,7 @@ name MPlayer version 1.0rc4 +revision 1 categories multimedia maintainers nomaintainer description The Unix movie player Modified: trunk/dports/multimedia/VLC/Portfile =================================================================== --- trunk/dports/multimedia/VLC/Portfile 2011-06-29 07:40:52 UTC (rev 79904) +++ trunk/dports/multimedia/VLC/Portfile 2011-06-29 07:41:42 UTC (rev 79905) @@ -6,7 +6,7 @@ name VLC version 1.0.6 -revision 5 +revision 6 categories multimedia Modified: trunk/dports/multimedia/VLC09/Portfile =================================================================== --- trunk/dports/multimedia/VLC09/Portfile 2011-06-29 07:40:52 UTC (rev 79904) +++ trunk/dports/multimedia/VLC09/Portfile 2011-06-29 07:41:42 UTC (rev 79905) @@ -5,7 +5,7 @@ name VLC09 version 0.9.10 -revision 6 +revision 7 categories multimedia Modified: trunk/dports/multimedia/avidemux/Portfile =================================================================== --- trunk/dports/multimedia/avidemux/Portfile 2011-06-29 07:40:52 UTC (rev 79904) +++ trunk/dports/multimedia/avidemux/Portfile 2011-06-29 07:41:42 UTC (rev 79905) @@ -5,7 +5,7 @@ name avidemux version 2.5.3 -revision 4 +revision 5 categories multimedia platforms darwin maintainers nomaintainer @@ -26,7 +26,8 @@ depends_build-append \ port:pkgconfig \ - port:yasm + port:yasm \ + port:dos2unix depends_lib-append port:gtk2 \ path:lib/pkgconfig/glib-2.0.pc:glib2 \ @@ -42,8 +43,13 @@ patch-ffmpeg-libs-naming.diff \ patch-ffmpeg-configure.diff \ patch-no-bundles.diff \ - patch-libsdl_CMakeLists.txt.diff + patch-libsdl_CMakeLists.txt.diff \ + patch-x264.diff +pre-patch { + system "cd ${worksrcpath}/plugins/ADM_videoEncoder/ADM_vidEnc_x264 && dos2unix *.h *.cpp" +} + # do a out of place build pre-configure { file mkdir ${workpath}/build Added: trunk/dports/multimedia/avidemux/files/patch-x264.diff =================================================================== --- trunk/dports/multimedia/avidemux/files/patch-x264.diff (rev 0) +++ trunk/dports/multimedia/avidemux/files/patch-x264.diff 2011-06-29 07:41:42 UTC (rev 79905) @@ -0,0 +1,1191 @@ +diff -Naurp plugins/ADM_videoEncoder/ADM_vidEnc_x264/encoder.cpp plugins/ADM_videoEncoder/ADM_vidEnc_x264/encoder.cpp +--- plugins/ADM_videoEncoder/ADM_vidEnc_x264/encoder.cpp 2011-06-29 00:22:07.000000000 -0700 ++++ plugins/ADM_videoEncoder/ADM_vidEnc_x264/encoder.cpp 2011-06-29 00:38:27.000000000 -0700 +@@ -193,29 +193,10 @@ int x264Encoder::open(vidEncVideoPropert + _buffer = new uint8_t[_bufferSize]; + + memcpy(&_properties, properties, sizeof(vidEncVideoProperties)); +- updateEncodeParameters(&_properties); +- +- _param.i_width = _properties.width; +- _param.i_height = _properties.height; +- _param.i_fps_num = _properties.fpsNum; +- _param.i_fps_den = _properties.fpsDen; +- +- if (_options.getSarAsInput()) +- { +- _param.vui.i_sar_width = _properties.parWidth; +- _param.vui.i_sar_height = _properties.parHeight; +- } +- +- if (properties->flags & ADM_VIDENC_FLAG_GLOBAL_HEADER) +- _param.b_repeat_headers = 0; +- else +- _param.b_repeat_headers = 1; + + properties->supportedCspsCount = 1; + properties->supportedCsps = supportedCsps; + +- printParam(&_param); +- + return ADM_VIDENC_ERR_SUCCESS; + } + +@@ -245,6 +226,7 @@ int x264Encoder::beginPass(vidEncPassPar + char *logFileName = NULL; + + printf("[x264] begin pass %d/%d\n", _currentPass, _passCount); ++ updateEncodeParameters(&_properties); + + if (_passCount > 1) + { +@@ -278,6 +260,12 @@ int x264Encoder::beginPass(vidEncPassPar + _param.rc.b_stat_read = 0; + } + ++#if X264_BUILD > 85 ++ if (_passCount > 1 && _currentPass == 1 && _options.getFastFirstPass()) ++ x264_param_apply_fastfirstpass(&_param); ++#endif ++ ++ printParam(&_param); + _handle = x264_encoder_open(&_param); + + if (logFileName) +@@ -327,7 +315,6 @@ int x264Encoder::encodeFrame(vidEncEncod + _picture.img.i_plane = 3; + } + +-#if X264_BUILD > 75 + if (x264_encoder_encode(_handle, &nal, &nalCount, encodeParams->frameData[0] ? &_picture : NULL, &picture_out) < 0) + { + printf("[x264] Error encoding\n"); +@@ -343,80 +330,27 @@ int x264Encoder::encodeFrame(vidEncEncod + } + + encodeParams->encodedDataSize = size; +-#else +- if (x264_encoder_encode(_handle, &nal, &nalCount, encodeParams->frameData[0] ? &_picture : NULL, &picture_out) < 0) +- { +- printf("[x264] Error encoding\n"); +- return ADM_VIDENC_ERR_FAILED; +- } +- +- int size = 0; +- int currentNal, sizemax; +- +- for (int i = 0; i < nalCount; i++) +- { +- sizemax = 0xfffffff; +- +- if (!_param.b_repeat_headers) +- size += 4; +- +- currentNal = x264_nal_encode(_buffer + size, &sizemax, _param.b_repeat_headers, &nal[i]); +- +- if (!_param.b_repeat_headers) +- { +- // Need to put size (assuming nal_size=4) +- _buffer[size + 0 - 4] = (currentNal >> 24) & 0xff; +- _buffer[size + 1 - 4] = (currentNal >> 16) & 0xff; +- _buffer[size + 2 - 4] = (currentNal >> 8) & 0xff; +- _buffer[size + 3 - 4] = (currentNal >> 0) & 0xff; +- } +- +- size += currentNal; +- } +- +- encodeParams->encodedDataSize = size; +-#endif + + _currentFrame++; + encodeParams->ptsFrame = picture_out.i_pts; // In fact it is the picture number in out case + +- switch (picture_out.i_type) ++ if (picture_out.b_keyframe) ++ encodeParams->frameType = ADM_VIDENC_FRAMETYPE_IDR; ++ else + { +- case X264_TYPE_IDR: +- encodeParams->frameType = ADM_VIDENC_FRAMETYPE_IDR; +-#if X264_BUILD < 76 +- if(!_param.b_repeat_headers && _seiUserData && !picture_out.i_pts) +- { +- // Put our SEI front... +- // first a temp location... +- uint8_t tmpBuffer[size]; +- memcpy(tmpBuffer, _buffer, size); +- +- // Put back out SEI and add Size +- _buffer[0] = (_seiUserDataLen >> 24) & 0xff; +- _buffer[1] = (_seiUserDataLen >> 16) & 0xff; +- _buffer[2] = (_seiUserDataLen >> 8) & 0xff; +- _buffer[3] = (_seiUserDataLen >> 0) & 0xff; +- +- memcpy(_buffer + 4, _seiUserData, _seiUserDataLen); +- memcpy(_buffer + 4 + _seiUserDataLen, tmpBuffer, size); +- +- size += 4 + _seiUserDataLen; +- encodeParams->encodedDataSize = size; // update total size +- } +-#endif +- +- break; +- case X264_TYPE_I: +- case X264_TYPE_P: +- encodeParams->frameType = ADM_VIDENC_FRAMETYPE_P; +- break; +- case X264_TYPE_B: +- case X264_TYPE_BREF: +- encodeParams->frameType = ADM_VIDENC_FRAMETYPE_B; +- break; +- default: +- encodeParams->frameType = ADM_VIDENC_FRAMETYPE_NULL; ++ switch (picture_out.i_type) ++ { ++ case X264_TYPE_I: ++ case X264_TYPE_P: ++ encodeParams->frameType = ADM_VIDENC_FRAMETYPE_P; ++ break; ++ case X264_TYPE_B: ++ case X264_TYPE_BREF: ++ encodeParams->frameType = ADM_VIDENC_FRAMETYPE_B; ++ break; ++ default: ++ encodeParams->frameType = ADM_VIDENC_FRAMETYPE_NULL; ++ } + } + + encodeParams->quantiser = picture_out.i_qpplus1 - 1; +@@ -425,7 +359,6 @@ int x264Encoder::encodeFrame(vidEncEncod + return ADM_VIDENC_ERR_SUCCESS; + } + +-#if X264_BUILD > 75 + int x264Encoder::encodeNals(uint8_t *buf, int size, x264_nal_t *nals, int nalCount, bool skipSei) + { + uint8_t *p = buf; +@@ -454,7 +387,6 @@ int x264Encoder::encodeNals(uint8_t *buf + + return p - buf; + } +-#endif + + bool x264Encoder::createHeader(void) + { +@@ -467,98 +399,9 @@ bool x264Encoder::createHeader(void) + if (_extraData) + delete _extraData; + +-#if X264_BUILD > 75 + _extraDataSize = x264_encoder_headers(_handle, &nal, &nalCount); + _extraData = new uint8_t[_extraDataSize]; + _extraDataSize = encodeNals(_extraData, _extraDataSize, nal, nalCount, true); +-#else +- uint32_t offset = 0; +- uint8_t buffer[X264_MAX_HEADER_SIZE]; +- uint8_t picParam[X264_MAX_HEADER_SIZE]; +- uint8_t seqParam[X264_MAX_HEADER_SIZE]; +- uint8_t sei[X264_MAX_HEADER_SIZE]; +- int picParamLen = 0, seqParamLen = 0, seiParamLen = 0, len; +- int sz; +- +- _extraData = new uint8_t[X264_MAX_HEADER_SIZE]; +- _extraDataSize = 0; +- +- x264_encoder_headers(_handle, &nal, &nalCount); +- +- printf("[x264] Nal count: %d\n", nalCount); +- +- // Now encode them +- for (int i = 0; i < nalCount; i++) +- { +- switch (nal[i].i_type) +- { +- case H264_NAL_TYPE_SEQ_PARAM: +- sz = x264_nal_encode(seqParam, &seqParamLen, 0, &nal[i]); +- break; +- case H264_NAL_TYPE_PIC_PARAM: +- sz = x264_nal_encode(picParam, &picParamLen, 0, &nal[i]); +- break; +- case H264_NAL_TYPE_SEI: +- sz = x264_nal_encode(sei, &seiParamLen, 0, &nal[i]); +- break; +- default: +- printf("[x264] Unknown type %d in nal %d\n", nal[i].i_type, i); +- sz = x264_nal_encode(buffer, &len, 0, &nal[i]); +- } +- +- if (sz <= 0) +- { +- printf("[x264] Cannot encode nal header %d\n", i); +- +- return false; +- } +- } +- +- // Now that we got all the nals encoded, time to build the avcC atom +- // Check we have everything we want +- if (!picParamLen || !seqParamLen) +- { +- printf("[x264] Seqparam or PicParam not found\n"); +- return false; +- } +- +- // Fill header +- _extraData[0] = 1; // Version +- _extraData[1] = seqParam[1]; //0x42; // AVCProfileIndication +- _extraData[2] = seqParam[2]; //0x00; // profile_compatibility +- _extraData[3] = seqParam[3]; //0x0D; // AVCLevelIndication +- _extraData[4] = 0xFC + 3; // lengthSizeMinusOne +- _extraData[5] = 0xE0 + 1; // nonReferenceDegredationPriorityLow +- +- offset = 6; +- _extraData[offset] = seqParamLen >> 8; +- _extraData[offset + 1] = seqParamLen & 0xff; +- +- offset += 2; +- memcpy(_extraData + offset, seqParam, seqParamLen); +- +- offset += seqParamLen; +- _extraData[offset] = 1; // numOfPictureParameterSets +- +- offset++; +- _extraData[offset] = picParamLen >> 8; +- _extraData[offset + 1] = picParamLen & 0xff; +- +- offset += 2; +- memcpy(_extraData + offset, picParam, picParamLen); +- +- offset += picParamLen; +- +- // Where x264 stores all its header, save it for later use +- if (seiParamLen) +- { +- _seiUserDataLen = seiParamLen; +- _seiUserData = new uint8_t[_seiUserDataLen]; +- memcpy(_seiUserData, sei, _seiUserDataLen); +- } +- +- _extraDataSize = offset; +-#endif + + printf("[x264] generated %d extra bytes for header\n", _extraDataSize); + +@@ -624,10 +467,16 @@ void x264Encoder::printParam(x264_param_ + + printf("\n[x264] i_width = %d, i_height = %d\n", x264Param->i_width, x264Param->i_height); + printf("[x264] i_csp = %d\n", x264Param->i_csp); ++#if X264_BUILD > 88 ++ printf("[x264] i_nal_hrd = %d\n", x264Param->i_nal_hrd); ++#endif + printf("[x264] i_fps_num = %d, i_fps_den = %d\n", x264Param->i_fps_num, x264Param->i_fps_den); + printf("[x264] rc.i_rc_method = %d\n", x264Param->rc.i_rc_method); + printf("[x264] rc.i_bitrate = %d\n", x264Param->rc.i_bitrate); + printf("[x264] rc.f_rf_constant = %f\n", x264Param->rc.f_rf_constant); ++#if X264_BUILD > 89 ++ printf("[x264] rc.f_rf_constant_max = %f\n", x264Param->rc.f_rf_constant_max); ++#endif + printf("[x264] rc.i_qp_constant = %d\n", x264Param->rc.i_qp_constant); + printf("[x264] analyse.i_subpel_refine = %d\n", x264Param->analyse.i_subpel_refine); + printf("[x264] analyse.i_me_method = %d\n", x264Param->analyse.i_me_method); +@@ -639,22 +488,31 @@ void x264Encoder::printParam(x264_param_ + printf("[x264] analyse.b_transform_8x8 = %d\n", x264Param->analyse.b_transform_8x8); + printf("[x264] analyse.inter = %d\n", x264Param->analyse.inter); + printf("[x264] b_cabac = %d\n", x264Param->b_cabac); ++#if X264_BUILD > 114 ++ printf("[x264] b_open_gop = %d\n", x264Param->b_open_gop); ++ printf("[x264] b_bluray_compat = %d\n", x264Param->b_bluray_compat); ++#elif X264_BUILD > 101 ++ printf("[x264] i_open_gop = %d\n", x264Param->i_open_gop); ++#endif + printf("[x264] b_interlaced = %d\n", x264Param->b_interlaced); ++#if X264_BUILD > 88 ++ printf("[x264] b_tff = %d\n", x264Param->b_tff); ++#endif ++#if X264_BUILD > 95 ++ printf("[x264] b_fake_interlaced = %d\n", x264Param->b_fake_interlaced); ++#endif + printf("[x264] b_deblocking_filter = %d\n", x264Param->b_deblocking_filter); + printf("[x264] i_deblocking_filter_alphac0 = %d\n", x264Param->i_deblocking_filter_alphac0); + printf("[x264] i_deblocking_filter_beta = %d\n", x264Param->i_deblocking_filter_beta); + printf("[x264] i_bframe = %d\n", x264Param->i_bframe); + printf("[x264] i_bframe_bias = %d\n", x264Param->i_bframe_bias); + printf("[x264] i_frame_reference = %d\n", x264Param->i_frame_reference); +-#if X264_BUILD >= 78 + printf("[x264] i_bframe_pyramid = %d\n", x264Param->i_bframe_pyramid); +-#else +- printf("[x264] b_bframe_pyramid = %d\n", x264Param->b_bframe_pyramid); +-#endif + printf("[x264] i_bframe_adaptive = %d\n", x264Param->i_bframe_adaptive); + printf("[x264] i_keyint_max = %d\n", x264Param->i_keyint_max); + printf("[x264] i_keyint_min = %d\n", x264Param->i_keyint_min); + printf("[x264] i_scenecut_threshold = %d\n", x264Param->i_scenecut_threshold); ++ printf("[x264] b_intra_refresh = %d\n", x264Param->b_intra_refresh); + printf("[x264] analyse.b_mixed_references = %d\n", x264Param->analyse.b_mixed_references); + printf("[x264] analyse.b_chroma_me = %d\n", x264Param->analyse.b_chroma_me); + printf("[x264] analyse.i_trellis = %d\n", x264Param->analyse.i_trellis); +@@ -752,6 +610,25 @@ void x264Encoder::updateEncodeParameters + _param.rc.i_bitrate = _encodeOptions.encodeModeParameter; + break; + } ++ ++ if (properties) ++ { ++ _param.i_width = properties->width; ++ _param.i_height = properties->height; ++ _param.i_fps_num = properties->fpsNum; ++ _param.i_fps_den = properties->fpsDen; ++ ++ if (_options.getSarAsInput()) ++ { ++ _param.vui.i_sar_width = properties->parWidth; ++ _param.vui.i_sar_height = properties->parHeight; ++ } ++ ++ if (properties->flags & ADM_VIDENC_FLAG_GLOBAL_HEADER) ++ _param.b_repeat_headers = 0; ++ else ++ _param.b_repeat_headers = 1; ++ } + } + + unsigned int x264Encoder::calculateBitrate(unsigned int fpsNum, unsigned int fpsDen, unsigned int frameCount, unsigned int sizeInMb) +diff -Naurp plugins/ADM_videoEncoder/ADM_vidEnc_x264/x264Options.cpp plugins/ADM_videoEncoder/ADM_vidEnc_x264/x264Options.cpp +--- plugins/ADM_videoEncoder/ADM_vidEnc_x264/x264Options.cpp 2011-06-29 00:22:07.000000000 -0700 ++++ plugins/ADM_videoEncoder/ADM_vidEnc_x264/x264Options.cpp 2011-06-29 00:38:27.000000000 -0700 +@@ -52,9 +52,12 @@ void x264Options::reset(void) + x264_param_default(&_param); + _param.vui.i_sar_height = 1; + _param.vui.i_sar_width = 1; +- _param.i_threads = 0; // set to auto-detect; default is disabled + + _sarAsInput = false; ++ ++#if X264_BUILD > 85 ++ _fastFirstPast = true; ++#endif + } + + x264_param_t* x264Options::getParameters(void) +@@ -75,6 +78,18 @@ x264_param_t* x264Options::getParameters + return param; + } + ++#if X264_BUILD > 85 ++bool x264Options::getFastFirstPass(void) ++{ ++ return _fastFirstPast; ++} ++ ++void x264Options::setFastFirstPass(bool fastFirstPass) ++{ ++ _fastFirstPast = fastFirstPass; ++} ++#endif ++ + int x264Options::getThreads(void) + { + return _param.i_threads; +@@ -96,7 +111,16 @@ void x264Options::setDeterministic(bool + _param.b_deterministic = deterministic; + } + +-#if X264_BUILD >= 75 ++bool x264Options::getSliceThreading(void) ++{ ++ return _param.b_sliced_threads; ++} ++ ++void x264Options::setSliceThreading(bool sliceThreading) ++{ ++ _param.b_sliced_threads = sliceThreading; ++} ++ + int x264Options::getThreadedLookahead(void) + { + return _param.i_sync_lookahead; +@@ -107,7 +131,6 @@ void x264Options::setThreadedLookahead(i + if (frames >= -1 && frames <= 250) + _param.i_sync_lookahead = frames; + } +-#endif + + int x264Options::getIdcLevel(void) + { +@@ -268,11 +291,21 @@ void x264Options::setGopMinimumSize(unsi + + unsigned int x264Options::getGopMaximumSize(void) + { ++#if X264_BUILD > 101 ++ if (_param.i_keyint_max == X264_KEYINT_MAX_INFINITE) ++ return 0; ++ else ++#endif + return _param.i_keyint_max; + } + + void x264Options::setGopMaximumSize(unsigned int gopSize) + { ++#if X264_BUILD > 101 ++ if (gopSize == 0) ++ _param.i_keyint_max = X264_KEYINT_MAX_INFINITE; ++ else ++#endif + if (gopSize <= 1000) + _param.i_keyint_max = gopSize; + } +@@ -288,6 +321,16 @@ void x264Options::setScenecutThreshold(u + _param.i_scenecut_threshold = scenecutThreshold; + } + ++bool x264Options::getIntraRefresh(void) ++{ ++ return _param.b_intra_refresh; ++} ++ ++void x264Options::setIntraRefresh(bool intraRefresh) ++{ ++ _param.b_intra_refresh = intraRefresh; ++} ++ + unsigned int x264Options::getBFrames(void) + { + return _param.i_bframe; +@@ -323,21 +366,13 @@ void x264Options::setBFrameBias(int bFra + + unsigned int x264Options::getBFrameReferences(void) + { +-#if X264_BUILD >= 78 + return _param.i_bframe_pyramid; +-#else +- return _param.b_bframe_pyramid; +-#endif + } + + void x264Options::setBFrameReferences(unsigned int bFrameReferences) + { +-#if X264_BUILD >= 78 + if (bFrameReferences <= 2) + _param.i_bframe_pyramid = bFrameReferences; +-#else +- _param.b_bframe_pyramid = !!bFrameReferences; +-#endif + } + + bool x264Options::getLoopFilter(void) +@@ -382,17 +417,77 @@ void x264Options::setCabac(bool cabac) + _param.b_cabac = cabac; + } + +-bool x264Options::getInterlaced(void) ++#if X264_BUILD > 101 ++unsigned int x264Options::getOpenGopMode(void) ++{ ++#if X264_BUILD > 114 ++ if (_param.b_open_gop == 1) ++ { ++ if (_param.b_bluray_compat == 1) ++ { ++ return 2; ++ } ++ else ++ { ++ return 1; ++ } ++ } ++ ++ return 0; ++#else ++ return _param.i_open_gop; ++#endif ++} ++ ++void x264Options::setOpenGopMode(unsigned int openGopMode) ++{ ++#if X264_BUILD > 114 ++ _param.b_open_gop = (openGopMode > 0 ? 1 : 0); ++ _param.b_bluray_compat = (openGopMode == 2 ? 1 : 0); ++#else ++ if (openGopMode < 3) ++ _param.i_open_gop = openGopMode; ++#endif ++} ++#endif ++ ++unsigned int x264Options::getInterlaced(void) + { ++#if X264_BUILD > 88 ++ if (_param.b_interlaced) ++ { ++ if (_param.b_tff) ++ return 2; ++ else ++ return 1; ++ } ++ else ++ { ++# if X264_BUILD > 95 ++ if (_param.b_fake_interlaced) ++ return 3; ++ else ++#endif ++ return 0; ++ } ++#else + return _param.b_interlaced; ++#endif + } + +-void x264Options::setInterlaced(bool interlaced) ++void x264Options::setInterlaced(unsigned int interlaced) + { +- _param.b_interlaced = interlaced; ++ _param.b_interlaced = (interlaced == 1 || interlaced == 2); ++ ++#if X264_BUILD > 88 ++ _param.b_tff = (interlaced == 2 ? 1 : 0); ++#endif ++ ++#if X264_BUILD > 95 ++ _param.b_fake_interlaced = (interlaced == 3 ? 1 : 0); ++#endif + } + +-#if X264_BUILD >= 77 + bool x264Options::getConstrainedIntraPrediction(void) + { + return _param.b_constrained_intra; +@@ -402,7 +497,6 @@ void x264Options::setConstrainedIntraPre + { + _param.b_constrained_intra = constrainedIntra; + } +-#endif + + unsigned int x264Options::getCqmPreset(void) + { +@@ -550,7 +644,6 @@ void x264Options::setDct8x8(bool dct8x8) + _param.analyse.b_transform_8x8 = dct8x8; + } + +-#if X264_BUILD >= 79 + unsigned int x264Options::getWeightedPredictionPFrames(void) + { + return _param.analyse.i_weighted_pred; +@@ -560,7 +653,6 @@ void x264Options::setWeightedPredictionP + { + _param.analyse.i_weighted_pred = weightedPrediction; + } +-#endif + + bool x264Options::getWeightedPrediction(void) + { +@@ -644,7 +736,7 @@ unsigned int x264Options::getSubpixelRef + + void x264Options::setSubpixelRefinement(unsigned int subpixelRefinement) + { +- if (subpixelRefinement >= 1 && subpixelRefinement <= 9) ++ if (subpixelRefinement >= 1 && subpixelRefinement <= 10) + _param.analyse.i_subpel_refine = subpixelRefinement; + } + +@@ -706,10 +798,21 @@ float x264Options::getPsychoRdo(void) + + void x264Options::setPsychoRdo(float psychoRdo) + { +- if (psychoRdo >= 0 && psychoRdo <= 10) ++ if (psychoRdo >= 0.0f && psychoRdo <= 10.0f) + _param.analyse.f_psy_rd = psychoRdo; + } + ++float x264Options::getPsychoTrellis(void) ++{ ++ return _param.analyse.f_psy_trellis; ++} ++ ++void x264Options::setPsychoTrellis(float psychoTrellis) ++{ ++ if (psychoTrellis >= 0.0f && psychoTrellis <= 10.0f) ++ _param.analyse.f_psy_trellis = psychoTrellis; ++} ++ + unsigned int x264Options::getNoiseReduction(void) + { + return _param.analyse.i_noise_reduction; +@@ -750,7 +853,7 @@ unsigned int x264Options::getQuantiserMi + + void x264Options::setQuantiserMinimum(unsigned int quantiserMinimum) + { +- if (quantiserMinimum >= 10 && quantiserMinimum <= 51) ++ if (quantiserMinimum <= 51) + _param.rc.i_qp_min = quantiserMinimum; + } + +@@ -761,7 +864,7 @@ unsigned int x264Options::getQuantiserMa + + void x264Options::setQuantiserMaximum(unsigned int quantiserMaximum) + { +- if (quantiserMaximum >= 10 && quantiserMaximum <= 51) ++ if (quantiserMaximum <= 51) + _param.rc.i_qp_max = quantiserMaximum; + } + +@@ -776,6 +879,19 @@ void x264Options::setQuantiserStep(unsig + _param.rc.i_qp_step = quantiserStep; + } + ++#if X264_BUILD > 89 ++unsigned int x264Options::getMaximumConstantRateFactor(void) ++{ ++ return (unsigned int)_param.rc.f_rf_constant_max; ++} ++ ++void x264Options::setMaximumConstantRateFactor(unsigned int maxCrf) ++{ ++ if (maxCrf <= 51) ++ _param.rc.f_rf_constant_max = maxCrf; ++} ++#endif ++ + float x264Options::getAverageBitrateTolerance(void) + { + return _param.rc.f_rate_tolerance; +@@ -849,7 +965,7 @@ unsigned int x264Options::getAdaptiveQua + + void x264Options::setAdaptiveQuantiserMode(unsigned int adaptiveQuantiserMode) + { +- if (adaptiveQuantiserMode <= 1) ++ if (adaptiveQuantiserMode <= X264_AQ_AUTOVARIANCE) + _param.rc.i_aq_mode = adaptiveQuantiserMode; + } + +@@ -863,7 +979,6 @@ void x264Options::setAdaptiveQuantiserSt + _param.rc.f_aq_strength = adaptiveQuantiserStrength; + } + +-#if X264_BUILD >= 69 + bool x264Options::getMbTree(void) + { + return _param.rc.b_mb_tree; +@@ -884,7 +999,6 @@ void x264Options::setFrametypeLookahead( + if (frames <= 250) + _param.rc.i_lookahead = frames; + } +-#endif + + float x264Options::getQuantiserCurveCompression(void) + { +@@ -979,7 +1093,6 @@ void x264Options::setSpsIdentifier(unsig + } + } + +-#if X264_BUILD >= 73 + unsigned int x264Options::getSliceMaxSize(void) + { + return _param.i_slice_max_size; +@@ -1009,6 +1122,18 @@ void x264Options::setSliceCount(unsigned + { + _param.i_slice_count = sliceCount; + } ++ ++#if X264_BUILD > 88 ++unsigned int x264Options::getHrdParameter(void) ++{ ++ return _param.i_nal_hrd; ++} ++ ++void x264Options::setHrdParameter(unsigned int hrdParameter) ++{ ++ if (hrdParameter <= 2) ++ _param.i_nal_hrd = hrdParameter; ++} + #endif + + void x264Options::addOptionsToXml(xmlNodePtr xmlNodeRoot) +@@ -1018,11 +1143,13 @@ void x264Options::addOptionsToXml(xmlNod + xmlNodePtr xmlNodeChild, xmlNodeChild2; + + xmlNodeRoot = xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)getOptionsTagRoot(), NULL); ++#if X264_BUILD > 85 ++ xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"fastFirstPass", boolean2String(xmlBuffer, bufferSize, getFastFirstPass())); ++#endif + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"threads", number2String(xmlBuffer, bufferSize, getThreads())); + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"deterministic", boolean2String(xmlBuffer, bufferSize, getDeterministic())); +-#if X264_BUILD >= 75 ++ xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"sliceThreading", boolean2String(xmlBuffer, bufferSize, getSliceThreading())); + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"threadedLookahead", number2String(xmlBuffer, bufferSize, getThreadedLookahead())); +-#endif + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"idcLevel", number2String(xmlBuffer, bufferSize, getIdcLevel())); + + xmlNodeChild = xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"vui", NULL); +@@ -1164,11 +1291,11 @@ void x264Options::addOptionsToXml(xmlNod + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"gopMaximumSize", number2String(xmlBuffer, bufferSize, getGopMaximumSize())); + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"gopMinimumSize", number2String(xmlBuffer, bufferSize, getGopMinimumSize())); + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"scenecutThreshold", number2String(xmlBuffer, bufferSize, getScenecutThreshold())); ++ xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"periodicIntraRefresh", boolean2String(xmlBuffer, bufferSize, getIntraRefresh())); + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"bFrames", number2String(xmlBuffer, bufferSize, getBFrames())); + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"adaptiveBframeDecision", number2String(xmlBuffer, bufferSize, getAdaptiveBFrameDecision())); + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"bFrameBias", number2String(xmlBuffer, bufferSize, getBFrameBias())); + +-#if X264_BUILD >= 78 + switch (getBFrameReferences()) + { + case 0: +@@ -1183,19 +1310,48 @@ void x264Options::addOptionsToXml(xmlNod + } + + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"bFrameReferences", xmlBuffer); +-#else +- xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"bFrameReferences", boolean2String(xmlBuffer, bufferSize, (bool)getBFrameReferences())); +-#endif +- +- + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"loopFilter", boolean2String(xmlBuffer, bufferSize, getLoopFilter())); + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"loopFilterAlphaC0", number2String(xmlBuffer, bufferSize, getLoopFilterAlphaC0())); + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"loopFilterBeta", number2String(xmlBuffer, bufferSize, getLoopFilterBeta())); + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"cabac", boolean2String(xmlBuffer, bufferSize, getCabac())); +- xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"interlaced", boolean2String(xmlBuffer, bufferSize, getInterlaced())); +-#if X264_BUILD >= 77 +- xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"constrainedIntraPrediction", boolean2String(xmlBuffer, bufferSize, getConstrainedIntraPrediction())); ++ ++#if X264_BUILD > 101 ++ switch (getOpenGopMode()) ++ { ++ case 1: ++ strcpy((char*)xmlBuffer, "normal"); ++ break; ++ case 2: ++ strcpy((char*)xmlBuffer, "bluray"); ++ break; ++ default: ++ strcpy((char*)xmlBuffer, "disabled"); ++ break; ++ } ++ ++ xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"openGop", xmlBuffer); ++#endif ++ ++ switch (getInterlaced()) ++ { ++ case 1: ++ strcpy((char*)xmlBuffer, "bff"); ++ break; ++ case 2: ++ strcpy((char*)xmlBuffer, "tff"); ++ break; ++#if X264_BUILD > 95 ++ case 3: ++ strcpy((char*)xmlBuffer, "fake"); ++ break; + #endif ++ default: ++ strcpy((char*)xmlBuffer, "disabled"); ++ break; ++ } ++ ++ xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"interlaced", xmlBuffer); ++ xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"constrainedIntraPrediction", boolean2String(xmlBuffer, bufferSize, getConstrainedIntraPrediction())); + + switch (getCqmPreset()) + { +@@ -1257,23 +1413,26 @@ void x264Options::addOptionsToXml(xmlNod + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"partitionB8x8", boolean2String(xmlBuffer, bufferSize, getPartitionB8x8())); + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"dct8x8", boolean2String(xmlBuffer, bufferSize, getDct8x8())); + +-#if X264_BUILD >= 79 + switch (getWeightedPredictionPFrames()) + { + case X264_WEIGHTP_NONE: + strcpy((char*)xmlBuffer, "none"); + break; ++#if X264_BUILD < 110 + case X264_WEIGHTP_BLIND: + strcpy((char*)xmlBuffer, "blind"); + break; ++#else ++ case X264_WEIGHTP_SIMPLE: ++ strcpy((char*)xmlBuffer, "simple"); ++ break; ++#endif + case X264_WEIGHTP_SMART: + strcpy((char*)xmlBuffer, "smart"); + break; + } + + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"weightedPredictionPframes", xmlBuffer); +-#endif +- + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"weightedPrediction", boolean2String(xmlBuffer, bufferSize, getWeightedPrediction())); + + switch (getDirectPredictionMode()) +@@ -1340,6 +1499,7 @@ void x264Options::addOptionsToXml(xmlNod + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"fastPSkip", boolean2String(xmlBuffer, bufferSize, getFastPSkip())); + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"dctDecimate", boolean2String(xmlBuffer, bufferSize, getDctDecimate())); + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"psychoRdo", number2String(xmlBuffer, bufferSize, getPsychoRdo())); ++ xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"psychoTrellis", number2String(xmlBuffer, bufferSize, getPsychoTrellis())); + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"noiseReduction", number2String(xmlBuffer, bufferSize, getNoiseReduction())); + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"interLumaDeadzone", number2String(xmlBuffer, bufferSize, getInterLumaDeadzone())); + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"intraLumaDeadzone", number2String(xmlBuffer, bufferSize, getIntraLumaDeadzone())); +@@ -1348,6 +1508,9 @@ void x264Options::addOptionsToXml(xmlNod + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"quantiserMinimum", number2String(xmlBuffer, bufferSize, getQuantiserMinimum())); + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"quantiserMaximum", number2String(xmlBuffer, bufferSize, getQuantiserMaximum())); + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"quantiserStep", number2String(xmlBuffer, bufferSize, getQuantiserStep())); ++#if X264_BUILD > 89 ++ xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"maximumConstantRateFactor", number2String(xmlBuffer, bufferSize, getMaximumConstantRateFactor())); ++#endif + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"averageBitrateTolerance", number2String(xmlBuffer, bufferSize, getAverageBitrateTolerance())); + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"vbvMaximumBitrate", number2String(xmlBuffer, bufferSize, getVbvMaximumBitrate())); + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"vbvBufferSize", number2String(xmlBuffer, bufferSize, getVbvBufferSize())); +@@ -1363,16 +1526,15 @@ void x264Options::addOptionsToXml(xmlNod + case X264_AQ_VARIANCE: + strcpy((char*)xmlBuffer, "variance"); + break; ++ case X264_AQ_AUTOVARIANCE: ++ strcpy((char*)xmlBuffer, "autoVariance"); ++ break; + } + + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"adaptiveQuantiserMode", xmlBuffer); + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"adaptiveQuantiserStrength", number2String(xmlBuffer, bufferSize, getAdaptiveQuantiserStrength())); +- +-#if X264_BUILD >= 69 + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"mbTree", boolean2String(xmlBuffer, bufferSize, getMbTree())); + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"frametypeLookahead", number2String(xmlBuffer, bufferSize, getFrametypeLookahead())); +-#endif +- + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"quantiserCurveCompression", number2String(xmlBuffer, bufferSize, getQuantiserCurveCompression())); + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"reduceFluxBeforeCurveCompression", number2String(xmlBuffer, bufferSize, getReduceFluxBeforeCurveCompression())); + xmlNewChild(xmlNodeChild, NULL, (xmlChar*)"reduceFluxAfterCurveCompression", number2String(xmlBuffer, bufferSize, getReduceFluxAfterCurveCompression())); +@@ -1404,11 +1566,25 @@ void x264Options::addOptionsToXml(xmlNod + + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"accessUnitDelimiters", boolean2String(xmlBuffer, bufferSize, getAccessUnitDelimiters())); + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"spsIdentifier", number2String(xmlBuffer, bufferSize, getSpsIdentifier())); +- +-#if X264_BUILD >= 73 + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"sliceMaxSize", number2String(xmlBuffer, bufferSize, getSliceMaxSize())); + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"sliceMaxMacroblocks", number2String(xmlBuffer, bufferSize, getSliceMaxMacroblocks())); + xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"sliceCount", number2String(xmlBuffer, bufferSize, getSliceCount())); ++ ++#if X264_BUILD > 88 ++ switch (getHrdParameter()) ++ { ++ case X264_NAL_HRD_VBR: ++ strcpy((char*)xmlBuffer, "vbr"); ++ break; ++ case X264_NAL_HRD_CBR: ++ strcpy((char*)xmlBuffer, "cbr"); ++ break; ++ default: ++ strcpy((char*)xmlBuffer, "none"); ++ break; ++ } ++ ++ xmlNewChild(xmlNodeRoot, NULL, (xmlChar*)"hrd", xmlBuffer); + #endif + } + +@@ -1429,12 +1605,16 @@ void x264Options::parseOptions(xmlNode * + + if (strcmp((char*)xmlChild->name, "threads") == 0) + setThreads(atoi(content)); ++#if X264_BUILD > 85 ++ else if (strcmp((char*)xmlChild->name, "fastFirstPass") == 0) ++ setFastFirstPass(string2Boolean(content)); ++#endif + else if (strcmp((char*)xmlChild->name, "deterministic") == 0) + setDeterministic(string2Boolean(content)); +-#if X264_BUILD >= 75 ++ else if (strcmp((char*)xmlChild->name, "sliceThreading") == 0) ++ setSliceThreading(string2Boolean(content)); + else if (strcmp((char*)xmlChild->name, "threadedLookahead") == 0) + setThreadedLookahead(atoi(content)); +-#endif + else if (strcmp((char*)xmlChild->name, "idcLevel") == 0) + setIdcLevel(atoi(content)); + else if (strcmp((char*)xmlChild->name, "vui") == 0) +@@ -1447,6 +1627,8 @@ void x264Options::parseOptions(xmlNode * + setGopMinimumSize(atoi(content)); + else if (strcmp((char*)xmlChild->name, "scenecutThreshold") == 0) + setScenecutThreshold(atoi(content)); ++ else if (strcmp((char*)xmlChild->name, "periodicIntraRefresh") == 0) ++ setIntraRefresh(string2Boolean(content)); + else if (strcmp((char*)xmlChild->name, "bFrames") == 0) + setBFrames(atoi(content)); + else if (strcmp((char*)xmlChild->name, "adaptiveBframeDecision") == 0) +@@ -1460,11 +1642,7 @@ void x264Options::parseOptions(xmlNode * + if (strcmp(content, "strict") == 0) + bFrameReferences = 1; + else if (strcmp(content, "normal") == 0 || strcmp(content, "1") == 0 || strcmp(content, "true") == 0) +-#if X264_BUILD >= 78 + bFrameReferences = 2; +-#else +- bFrameReferences = 1; +-#endif + + setBFrameReferences(bFrameReferences); + } +@@ -1476,12 +1654,34 @@ void x264Options::parseOptions(xmlNode * + setLoopFilterBeta(atoi(content)); + else if (strcmp((char*)xmlChild->name, "cabac") == 0) + setCabac(string2Boolean(content)); ++#if X264_BUILD > 101 ++ else if (strcmp((char*)xmlChild->name, "openGop") == 0) ++ { ++ int openGop = 0; ++ ++ if (strcmp(content, "normal") == 0) ++ openGop = 1; ++ else if (strcmp(content, "bluray") == 0) ++ openGop = 2; ++ ++ setOpenGopMode(openGop); ++ } ++#endif + else if (strcmp((char*)xmlChild->name, "interlaced") == 0) +- setInterlaced(string2Boolean(content)); +-#if X264_BUILD >= 77 ++ { ++ int interlaced = 0; ++ ++ if (strcmp(content, "bff") == 0) ++ interlaced = 1; ++ else if (strcmp(content, "tff") == 0) ++ interlaced = 2; ++ else if (strcmp(content, "fake") == 0) ++ interlaced = 3; ++ ++ setInterlaced(interlaced); ++ } + else if (strcmp((char*)xmlChild->name, "constrainedIntraPrediction") == 0) + setConstrainedIntraPrediction(string2Boolean(content)); +-#endif + else if (strcmp((char*)xmlChild->name, "cqmPreset") == 0) + { + int cqmPreset = 0; +@@ -1545,13 +1745,24 @@ void x264Options::parseOptions(xmlNode * + setAccessUnitDelimiters(string2Boolean(content)); + else if (strcmp((char*)xmlChild->name, "spsIdentifier") == 0) + setSpsIdentifier(atoi(content)); +-#if X264_BUILD >= 73 + else if (strcmp((char*)xmlChild->name, "sliceMaxSize") == 0) + setSliceMaxSize(atoi(content)); + else if (strcmp((char*)xmlChild->name, "sliceMaxMacroblocks") == 0) + setSliceMaxMacroblocks(atoi(content)); + else if (strcmp((char*)xmlChild->name, "sliceCount") == 0) + setSliceCount(atoi(content)); ++#if X264_BUILD > 88 ++ else if (strcmp((char*)xmlChild->name, "hrd") == 0) ++ { ++ unsigned int hdr = X264_NAL_HRD_NONE; ++ ++ if (strcmp(content, "vbr") == 0) ++ hdr = X264_NAL_HRD_VBR; ++ else if (strcmp(content, "cbr") == 0) ++ hdr = X264_NAL_HRD_CBR; ++ ++ setHrdParameter(hdr); ++ } + #endif + + xmlFree(content); +@@ -1722,19 +1933,22 @@ void x264Options::parseAnalyseOptions(xm + setPartitionB8x8(string2Boolean(content)); + else if (strcmp((char*)xmlChild->name, "dct8x8") == 0) + setDct8x8(string2Boolean(content)); +-#if X264_BUILD >= 79 + else if (strcmp((char*)xmlChild->name, "weightedPredictionPframes") == 0) + { + int weightedPredPFrames = X264_WEIGHTP_NONE; + ++#if X264_BUILD < 110 + if (strcmp(content, "blind") == 0) + weightedPredPFrames = X264_WEIGHTP_BLIND; ++#else ++ if (strcmp(content, "simple") == 0) ++ weightedPredPFrames = X264_WEIGHTP_SIMPLE; ++#endif + else if (strcmp(content, "smart") == 0) + weightedPredPFrames = X264_WEIGHTP_SMART; + + setWeightedPredictionPFrames(weightedPredPFrames); + } +-#endif + else if (strcmp((char*)xmlChild->name, "weightedPrediction") == 0) + setWeightedPrediction(string2Boolean(content)); + else if (strcmp((char*)xmlChild->name, "directPredictionMode") == 0) +@@ -1802,6 +2016,8 @@ void x264Options::parseAnalyseOptions(xm + setDctDecimate(string2Boolean(content)); + else if (strcmp((char*)xmlChild->name, "psychoRdo") == 0) + setPsychoRdo(string2Float(content)); ++ else if (strcmp((char*)xmlChild->name, "psychoTrellis") == 0) ++ setPsychoTrellis(string2Float(content)); + else if (strcmp((char*)xmlChild->name, "noiseReduction") == 0) + setNoiseReduction(atoi(content)); + else if (strcmp((char*)xmlChild->name, "interLumaDeadzone") == 0) +@@ -1828,6 +2044,10 @@ void x264Options::parseRateControlOption + setQuantiserMaximum(atoi(content)); + else if (strcmp((char*)xmlChild->name, "quantiserStep") == 0) + setQuantiserStep(atoi(content)); ++#if X264_BUILD > 89 ++ else if (strcmp((char*)xmlChild->name, "maximumConstantRateFactor") == 0) ++ setMaximumConstantRateFactor(atoi(content)); ++#endif + else if (strcmp((char*)xmlChild->name, "averageBitrateTolerance") == 0) + setAverageBitrateTolerance(string2Float(content)); + else if (strcmp((char*)xmlChild->name, "vbvMaximumBitrate") == 0) +@@ -1848,17 +2068,17 @@ void x264Options::parseRateControlOption + adaptiveQuantiserMode = X264_AQ_NONE; + else if (strcmp(content, "variance") == 0) + adaptiveQuantiserMode = X264_AQ_VARIANCE; ++ else if (strcmp(content, "autoVariance") == 0) ++ adaptiveQuantiserMode = X264_AQ_AUTOVARIANCE; + + setAdaptiveQuantiserMode(adaptiveQuantiserMode); + } + else if (strcmp((char*)xmlChild->name, "adaptiveQuantiserStrength") == 0) + setAdaptiveQuantiserStrength(string2Float(content)); +-#if X264_BUILD >= 69 + else if (strcmp((char*)xmlChild->name, "mbTree") == 0) + setMbTree(string2Boolean(content)); + else if (strcmp((char*)xmlChild->name, "frametypeLookahead") == 0) + setFrametypeLookahead(atoi(content)); +-#endif + else if (strcmp((char*)xmlChild->name, "quantiserCurveCompression") == 0) + setQuantiserCurveCompression(string2Float(content)); + else if (strcmp((char*)xmlChild->name, "reduceFluxBeforeCurveCompression") == 0) +diff -Naurp plugins/ADM_videoEncoder/ADM_vidEnc_x264/x264Options.h plugins/ADM_videoEncoder/ADM_vidEnc_x264/x264Options.h +--- plugins/ADM_videoEncoder/ADM_vidEnc_x264/x264Options.h 2011-06-29 00:22:07.000000000 -0700 ++++ plugins/ADM_videoEncoder/ADM_vidEnc_x264/x264Options.h 2011-06-29 00:38:26.000000000 -0700 +@@ -39,7 +39,9 @@ protected: + std::vector<x264ZoneOptions*> _zoneOptions; + + bool _sarAsInput; +- ++#if X264_BUILD > 85 ++ bool _fastFirstPast; ++#endif + void cleanUp(void); + + void addOptionsToXml(xmlNodePtr xmlNodeRoot); +@@ -58,16 +60,22 @@ public: + void reset(void); + x264_param_t* getParameters(void); + ++#if X264_BUILD > 85 ++ bool getFastFirstPass(void); ++ void setFastFirstPass(bool fastFirstPass); ++#endif ++ + int getThreads(void); + void setThreads(int threads); + + bool getDeterministic(void); + void setDeterministic(bool deterministic); + +-#if X264_BUILD >= 75 ++ bool getSliceThreading(void); ++ void setSliceThreading(bool sliceThreading); ++ + int getThreadedLookahead(void); + void setThreadedLookahead(int frames); +-#endif + + int getIdcLevel(void); + void setIdcLevel(int idcLevel); +@@ -114,6 +122,9 @@ public: + unsigned int getScenecutThreshold(void); + void setScenecutThreshold(unsigned int scenecutThreshold); + ++ bool getIntraRefresh(void); ++ void setIntraRefresh(bool intraRefresh); ++ + unsigned int getBFrames(void); + void setBFrames(unsigned int bFrames); + +@@ -138,13 +149,16 @@ public: + bool getCabac(void); + void setCabac(bool cabac); + +- bool getInterlaced(void); +- void setInterlaced(bool interlaced); ++#if X264_BUILD > 101 ++ unsigned int getOpenGopMode(void); ++ void setOpenGopMode(unsigned int openGopMode); ++#endif ++ ++ unsigned int getInterlaced(void); ++ void setInterlaced(unsigned int interlaced); + +-#if X264_BUILD >= 77 + bool getConstrainedIntraPrediction(void); + void setConstrainedIntraPrediction(bool constrainedIntra); +-#endif + + unsigned int getCqmPreset(void); + void setCqmPreset(unsigned int cqmPreset); +@@ -185,10 +199,8 @@ public: + bool getDct8x8(void); + void setDct8x8(bool dct8x8); + +-#if X264_BUILD >= 79 + unsigned int getWeightedPredictionPFrames(void); + void setWeightedPredictionPFrames(unsigned int weightedPrediction); +-#endif + + bool getWeightedPrediction(void); + void setWeightedPrediction(bool weightedPrediction); +@@ -232,6 +244,9 @@ public: + float getPsychoRdo(void); + void setPsychoRdo(float psychoRdo); + ++ float getPsychoTrellis(void); ++ void setPsychoTrellis(float psychoTrellis); ++ + unsigned int getNoiseReduction(void); + void setNoiseReduction(unsigned int noiseReduction); + +@@ -256,6 +271,11 @@ public: + unsigned int getQuantiserStep(void); + void setQuantiserStep(unsigned int quantiserStep); + ++#if X264_BUILD > 89 ++ unsigned int getMaximumConstantRateFactor(void); ++ void setMaximumConstantRateFactor(unsigned int maxCrf); ++#endif ++ + float getAverageBitrateTolerance(void); + void setAverageBitrateTolerance(float averageBitrateTolerance); + +@@ -280,13 +300,11 @@ public: + float getAdaptiveQuantiserStrength(void); + void setAdaptiveQuantiserStrength(float adaptiveQuantiserStrength); + +-#if X264_BUILD >= 69 + bool getMbTree(void); + void setMbTree(bool mbTree); + + unsigned int getFrametypeLookahead(void); + void setFrametypeLookahead(unsigned int frames); +-#endif + + float getQuantiserCurveCompression(void); + void setQuantiserCurveCompression(float quantiserCurveCompression); +@@ -308,7 +326,6 @@ public: + unsigned int getSpsIdentifier(void); + void setSpsIdentifier(unsigned int spsIdentifier); + +-#if X264_BUILD >= 73 + unsigned int getSliceMaxSize(void); + void setSliceMaxSize(unsigned int maxSize); + +@@ -317,6 +334,10 @@ public: + + unsigned int getSliceCount(void); + void setSliceCount(unsigned int sliceCount); ++ ++#if X264_BUILD > 88 ++ unsigned int getHrdParameter(void); ++ void setHrdParameter(unsigned int hrdParameter); + #endif + + int fromXml(const char *xml, PluginXmlType xmlType); Modified: trunk/dports/multimedia/ffmpeg/Portfile =================================================================== --- trunk/dports/multimedia/ffmpeg/Portfile 2011-06-29 07:40:52 UTC (rev 79904) +++ trunk/dports/multimedia/ffmpeg/Portfile 2011-06-29 07:41:42 UTC (rev 79905) @@ -8,6 +8,7 @@ conflicts ffmpeg-devel epoch 1 version 0.6.3 +revision 1 license nonfree GPL-2+ LGPL-2.1+ categories multimedia maintainers devans openmaintainer Modified: trunk/dports/multimedia/transcode/Portfile =================================================================== --- trunk/dports/multimedia/transcode/Portfile 2011-06-29 07:40:52 UTC (rev 79904) +++ trunk/dports/multimedia/transcode/Portfile 2011-06-29 07:41:42 UTC (rev 79905) @@ -5,7 +5,7 @@ name transcode version 1.1.5 -revision 1 +revision 2 epoch 1 categories multimedia maintainers cogweb.net:lionteeth devans