anytovcd.sh

来自「Motion JPEG编解码器源代码」· Shell 代码 · 共 1,015 行 · 第 1/2 页

    VID_FMT_OUT="m2v"
    VID_MINRATE_OUT="0"
    VID_MAXRATE_OUT="7500"

    VID_SAR_525_OUT="80:33"
    VID_SAR_625_OUT="236:81"
    VID_SIZE_525_OUT="352x480"
    VID_SIZE_625_OUT="352x576"
    
    AUD_FMT_OUT="ac3"
    AUD_BITRATE_OUT="192"
    AUD_FREQ_OUT="48000"
    AUD_CHANNELS_OUT="2"
    
    VOL_SIZE="4700"

elif test "${VCD_TYPE}" == "dvd"; then

    FF_ENC="${FF_ENC} -target dvd -f rawvideo -dc 10"
    MPEG2ENC="${MPEG2ENC} -f 8 -D 10"
    Y4MSCALER="${Y4MSCALER} -O preset=dvd"
    MPLEX="${MPLEX} -f 8"

    VID_FMT_OUT="m2v"
    VID_MINRATE_OUT="0"
    VID_MAXRATE_OUT="8000"
    
    VID_SAR_525_OUT="10:11"
    VID_SAR_625_OUT="59:54"
    VID_SIZE_525_OUT="720x480"
    VID_SIZE_625_OUT="720x576"
    
    AUD_FMT_OUT="ac3"
    AUD_BITRATE_OUT="192"
    AUD_FREQ_OUT="48000"
    AUD_CHANNELS_OUT="2"
    
    VOL_SIZE="4700"

elif test "${VCD_TYPE}" == "dvd_wide"; then

    FF_ENC="${FF_ENC} -target dvd -f rawvideo -dc 10"
    MPEG2ENC="${MPEG2ENC} -f 8 -D 10"
    Y4MSCALER="${Y4MSCALER} -O preset=dvd_wide"
    MPLEX="${MPLEX} -f 8"

    VID_FMT_OUT="m2v"
    VID_MINRATE_OUT="0"
    VID_MAXRATE_OUT="8000"
    
    VID_SAR_525_OUT="40:33"
    VID_SAR_625_OUT="118:81"
    VID_SIZE_525_OUT="720x480"
    VID_SIZE_625_OUT="720x576"
    
    AUD_FMT_OUT="ac3"
    AUD_BITRATE_OUT="192"
    AUD_FREQ_OUT="48000"
    AUD_CHANNELS_OUT="2"
    
    VOL_SIZE="4700"

elif test "${VCD_TYPE}" == "mvcd"; then

    FF_ENC="${FF_ENC} -vcodec mpeg1video -f rawvideo -bufsize 40 -me_range 64"
    MPEG2ENC="${MPEG2ENC} -f 2 -g 12 -G 24 -B 256 -S 797"
    Y4MSCALER="${Y4MSCALER} -O preset=vcd"
    MPLEX="${MPLEX} -f 2 -r 1400 -V"

    MATRICES="mvcd"
    VID_FMT_OUT="m1v"
    VID_ILACE_OUT="p"
    VID_MINRATE_OUT="0"
    VID_MAXRATE_OUT="1152"
    
    VID_SAR_525_OUT="10:11"
    VID_SAR_625_OUT="59:54"
    VID_SIZE_525_OUT="352x240"
    VID_SIZE_625_OUT="352x288"
    
    AUD_FMT_OUT="mp2"
    AUD_BITRATE_OUT="128"
    AUD_FREQ_OUT="44100"
    AUD_CHANNELS_OUT="2"
    
    # 360000 sectors * 2324 bytes per sector / 1000 / 1000
    VOL_SIZE="836"

elif test "${VCD_TYPE}" == "svcd"; then

    FF_ENC="${FF_ENC} -target svcd -f rawvideo"
    MPEG2ENC="${MPEG2ENC} -f 4 -B 256 -S 797"
    Y4MSCALER="${Y4MSCALER} -O preset=svcd"
    MPLEX="${MPLEX} -f 4"

    VID_FMT_OUT="m2v"
    VID_MINRATE_OUT="0"
    VID_MAXRATE_OUT="2500"
    
    VID_SAR_525_OUT="15:11"
    VID_SAR_625_OUT="59:36"
    VID_SIZE_525_OUT="480x480"
    VID_SIZE_625_OUT="480x576"
    
    AUD_FMT_OUT="mp2"
    AUD_BITRATE_OUT="224"
    AUD_FREQ_OUT="44100"
    AUD_CHANNELS_OUT="2"
    
    VOL_SIZE="836"

elif test "${VCD_TYPE}" == "vcd"; then

    ENC_TYPE="cbr"

    FF_ENC="${FF_ENC} -target vcd -f rawvideo -me_range 64"
    MPEG2ENC="${MPEG2ENC} -f 1 -B 256 -S 797"
    Y4MSCALER="${Y4MSCALER} -O preset=vcd"
    MPLEX="${MPLEX} -f 1"

    VID_FMT_OUT="m1v"
    VID_ILACE_OUT="p"
    
    VID_SAR_525_OUT="10:11"
    VID_SAR_625_OUT="59:54"
    VID_SIZE_525_OUT="352x240"
    VID_SIZE_625_OUT="352x288"
    
    AUD_FMT_OUT="mp2"
    AUD_BITRATE_OUT="224"
    AUD_FREQ_OUT="44100"
    AUD_CHANNELS_OUT="2"
    
    VOL_SIZE="836"

else

    show_error "the specified output type/profile is inexistant."
    show_help
    exit 2

fi

# audio pass-through
if test "${ACOPY_MODE}" == "1"; then

    AUD_BITRATE_OUT="${AUD_BITRATE_SRC}"
    AUD_FMT_OUT="${AUD_FMT_SRC}"
    AUD_FREQ_OUT="${AUD_FREQ_SRC}"

fi

# output filenames
VIDEO_OUT="${PREFIX_OUT}.${VID_FMT_OUT}"
AUDIO_OUT="${PREFIX_OUT}.${AUD_FMT_OUT}"
MPEG_OUT="${PREFIX_OUT}-%d.mpg"

# output interlacing
if test "${VID_ILACE_OUT}" == "b"; then

    FF_ENC="${FF_ENC} -ildct -ilme -top 0"
    MPEG2ENC="${MPEG2ENC} -I 1 -z b"

elif test "${VID_ILACE_OUT}" == "t"; then

    FF_ENC="${FF_ENC} -ildct -ilme -top 1"
    MPEG2ENC="${MPEG2ENC} -I 1 -z t"

else

    MPEG2ENC="${MPEG2ENC} -I 0"

fi

# output framerate
if test "${VID_FPS_SRC}" == "30000:1001" || test "${VID_FPS_SRC}" == "24000:1001" || test "${VID_FPS_SRC}" == "25:1"; then

    VID_FPS_OUT="${VID_FPS_SRC}"

elif test "${OUT_NORM}" == "ntsc"; then

    VID_FPS_OUT="30000:1001"

elif test "${OUT_NORM}" == "ntsc_film"; then

    VID_FPS_OUT="24000:1001"

else

    VID_FPS_OUT="25:1"

fi

# output sar and framesize for pal/ntsc
if test "${VID_FPS_OUT}" == "25:1"; then

    VID_SAR_OUT="${VID_SAR_625_OUT}"
    VID_SIZE_OUT="${VID_SIZE_625_OUT}"

else

    VID_SAR_OUT="${VID_SAR_525_OUT}"
    VID_SIZE_OUT="${VID_SIZE_525_OUT}"

fi

# cvd_wide "preset" for y4mscaler
if test "${VCD_TYPE}" == "cvd_wide"; then

    Y4MSCALER="${Y4MSCALER} -O sar=${VID_SAR_OUT} -O size=${VID_SIZE_OUT}"

fi

# pipe buffer
if which ${BFR} >/dev/null; then

    PIPE_BUFFER="${BFR} -b 16m |"

fi

# video decoder
if test "${DEC_TOOL}" == "mpeg2dec"; then

    test_bin ${MPEG2DEC}
    DECODER="${MPEG2DEC} -s -o pgmpipe \"${VIDEO_SRC}\" | ${PGMTOY4M} |"

elif test "${DEC_TOOL}" == "ffmpeg"; then

    test_bin ${FFMPEG}
    DECODER="${FF_DEC} -y /dev/stdout | ${PGMTOY4M} |"

else

    show_error "the specified video decoder tool is not used by this script."
    show_help
    exit 2

fi

# video filter
if test "${FILTERING}" == "none"; then

    FILTER=""

elif test "${FILTER_TYPE}" == "hqdenoise"; then

    test_bin ${Y4MDENOISE}
    FILTER="${Y4MDENOISE} ${Y4MDENOISE_FLAGS} |"

elif test "${FILTER_TYPE}" == "mean"; then
    
    test_bin ${YUVMEDIANFILTER}
    FILTER="${MEAN_FILTER} |"

elif test "${FILTER_TYPE}" == "median"; then

    test_bin ${YUVMEDIANFILTER}
    FILTER="${YUVMEDIANFILTER} |"

elif test "${FILTER_TYPE}" == "spatial"; then

    test_bin ${Y4MSPATIALFILTER}
    FILTER="${Y4MSPATIALFILTER} |"

elif test "${FILTER_TYPE}" == "temporal"; then

    test_bin ${YUVDENOISE}
    FILTER="${YUVDENOISE} |"

elif test "${FILTER_TYPE}" == "unsharp"; then

    test_bin ${Y4MUNSHARP}
    FILTER="${Y4MUNSHARP} |"

else

    show_error "the specified filter tool is not used by this script."
    show_help
    exit 2

fi

# video framerate correction
if test "${VID_FPS_SRC}" == "${VID_FPS_OUT}"; then

    FRC=""

else

    test_bin ${YUVFPS}
    FRC="${YUVFPS} -r ${VID_FPS_OUT} |"

fi

# video "deinterlacer"
if test "${VID_ILACE_SRC}" != "p" && test "${VID_ILACE_OUT}" == "p"; then

    Y4MSCALER="${Y4MSCALER} -I ilace=top_only"

fi

# video scaler
if test "${VID_SAR_SRC}" == "${VID_SAR_OUT}" && test "${VID_SIZE_SRC}" == "${VID_SIZE_OUT}"; then

    SCALER=""

else

    test_bin ${Y4MSCALER}
    SCALER="${Y4MSCALER} |"

fi

# 3:2 pulldown
if test "${VID_FPS_OUT}" == "24000:1001" && test "${VID_FMT_OUT}" == "m2v"; then

    FF_ENC="${FF_ENC}"
    MPEG2ENC="${MPEG2ENC} -p"

fi

# quantisation matrices
if test "${MATRICES}" == "kvcd"; then

    FF_ENC="${FF_ENC} -intra_matrix ${INTRA_KVCD} -inter_matrix ${INTER_KVCD}"
    MPEG2ENC="${MPEG2ENC} -K kvcd"

elif test "${MATRICES}" == "mvcd"; then

    echo "`matrix_copy ${INTRA_MVCD}`" > ${CQMFILE}
    echo "`matrix_copy ${INTER_MVCD}`" >> ${CQMFILE}

    FF_ENC="${FF_ENC} -intra_matrix ${INTRA_MVCD} -inter_matrix ${INTER_MVCD}"
    MPEG2ENC="${MPEG2ENC} -K file=${CQMFILE}"

elif test "${MATRICES}" == "tmpgenc"; then

    FF_ENC="${FF_ENC} -intra_matrix ${INTRA_TMPGENC} -inter_matrix ${INTER_TMPGENC}"
    MPEG2ENC="${MPEG2ENC} -K tmpgenc"

fi

# video encoding mode
if test "${ENC_TYPE}" == "cbr"; then

    # when using -q with mpeg2enc, variable bitrate is selected.
    # it's not ok for vcds...
    MPEG2ENC="${MPEG2ENC}"

elif test "${ENC_TYPE}" == "abr"; then

    if test "${DURATION}" != ""; then
    
        # input total time (seconds)
        VID_TIME_SRC="`echo "${DURATION}" | \
        awk '{print $1 * 60}'`"

    else
    
        # input length (frames)
        if echo "${VID_FMT_SRC}" | grep -e mpeg1 -e mpeg2 >/dev/null 2>&1; then
	
            test_bin ${TCCAT} && test_bin ${TCDEMUX}
            VID_LENGTH_SRC="`probe_mpeg_length "${VIDEO_SRC}"`"

        else

            test_bin ${TCPROBE}
            VID_LENGTH_SRC="`probe_vid_length "${VIDEO_SRC}"`"

        fi

        # input total time (seconds) = nb of frames / fps
        VID_TIME_SRC="`echo "${VID_LENGTH_SRC}:${VID_FPS_SRC}" | \
        awk -F: '{print $1 / $2 * $3 + 1}'`"

    fi
    
    test_bin bc
    
    # available kbits (k = 1000) per second = global bitrate
    BPS="`echo "${VOLUMES} * ${VOL_SIZE} * 1000 * 8 / ${VID_TIME_SRC}" | bc`"
    
    # muxing-overhead: 3% (0.97 * ...)
    VID_BITRATE_OUT="`echo "0.97 * ${BPS} - ${AUD_BITRATE_OUT}" | bc | \
    awk -F. '{print $1}'`"
    
    VID_BITRATE_OUT="`range_check ${VID_BITRATE_OUT} ${VID_MINRATE_OUT} ${VID_MAXRATE_OUT}`"
    
    FF_ENC="${FF_ENC} -minrate ${VID_MINRATE_OUT} -maxrate ${VID_MAXRATE_OUT} -b ${VID_BITRATE_OUT} -passlogfile ${STATFILE}"
    
    FF_STATS="${FF_ENC} -pass 1"
    MPEG2ENC_STATS="${MPEG2ENC} -b ${VID_BITRATE_OUT} -q 1 -v 1 2>${STATFILE}"
    
    FF_ENC="${FF_ENC} -pass 2"
    MPEG2ENC="${MPEG2ENC}"

else

    FF_ENC="${FF_ENC} -maxrate ${VID_MAXRATE_OUT} -qscale ${QUANT}"
    MPEG2ENC="${MPEG2ENC} -b ${VID_MAXRATE_OUT} -q ${QUANT}"

fi

# video encoder
if test "${ENC_TOOL}" == "ffmpeg"; then

    test_bin ${FFMPEG}
    ANALYSER="${FF_STATS} -y \"${VIDEO_OUT}\""
    ENCODER="${FF_ENC} -y \"${VIDEO_OUT}\""

elif test "${ENC_TOOL}" == "mpeg2enc"; then

    test_bin ${MPEG2ENC}
    ANALYSER="${MPEG2ENC_STATS} -o \"${VIDEO_OUT}\""
    ENCODER="${MPEG2ENC} -o \"${VIDEO_OUT}\""

else

    show_error "the specified video encoder tool is not used by this script."
    show_help
    exit 2

fi

# audio resampler
if test "${AUD_FREQ_SRC}" == "${AUD_FREQ_OUT}"; then

    AUDIO_RESAMPLER=""

else

    test_bin ${SOX}
    AUDIO_RESAMPLER="${SOX} -t au /dev/stdin -r ${AUD_FREQ_OUT} -t au /dev/stdout polyphase |"

fi

# audio decoder/encoder
if test "${ACOPY_MODE}" == "1"; then

    AUDIO_DECODER="${FFMPEG} ${FF_DEC_AFLAGS}"
    AUDIO_ENCODER="-acodec copy -y \"${AUDIO_OUT}\""

elif test "${AUD_FREQ_SRC}" == "${AUD_FREQ_OUT}"; then

    AUDIO_DECODER="${FFMPEG} ${FF_DEC_AFLAGS}"
    AUDIO_ENCODER="-ab ${AUD_BITRATE_OUT} -ac ${AUD_CHANNELS_OUT} -y \"${AUDIO_OUT}\""

else

    AUDIO_DECODER="${FFMPEG} ${FF_DEC_AFLAGS} -v 0 -f au -y /dev/stdout |"
    AUDIO_ENCODER="${FFMPEG} -f au -i /dev/stdin -ab ${AUD_BITRATE_OUT} -ac ${AUD_CHANNELS_OUT} -y \"${AUDIO_OUT}\""

fi

# output some info.
show_info "===== SOURCE STREAM ====================="
show_info "           frame size: ${VID_SIZE_SRC}"
show_info "           frame rate: ${VID_FPS_SRC}"
show_info "          interlacing: ${VID_ILACE_SRC}"
show_info "   pixel aspect ratio: ${VID_SAR_SRC}"
show_info "===== OUTPUT STREAM ====================="
show_info "           frame size: ${VID_SIZE_OUT}"
show_info "           frame rate: ${VID_FPS_OUT}"
show_info "          interlacing: ${VID_ILACE_OUT}"
show_info "   pixel aspect ratio: ${VID_SAR_OUT}"

# video "analyse"
if ! test "${BLIND_MODE}" == "1" && test "${ENC_TYPE}" == "abr"; then

    eval "${DECODER} ${FILTER} ${FRC} ${SCALER} ${PIPE_BUFFER} ${ANALYSER}"
    
    if test "${ENC_TOOL}" == "mpeg2enc"; then
    
        QUANT="`mpeg2enc_statfile_analyse ${STATFILE}`"
        QUANT="`range_check $QUANT 3 31`"
        ENCODER="${MPEG2ENC} -b ${VID_MAXRATE_OUT} -q ${QUANT} -o ${VIDEO_OUT}"

    fi

fi

# video (de)coding
if ! test "${BLIND_MODE}" == "1"; then

    eval "${DECODER} ${FILTER} ${FRC} ${SCALER} ${PIPE_BUFFER} ${ENCODER}"

fi

# audio (de)coding
if ! test "${MUTE_MODE}" == "1"; then

    eval "${AUDIO_DECODER} ${AUDIO_RESAMPLER} ${AUDIO_ENCODER}"

fi

# multiplexing
if ! test "${BLIND_MODE}" == "1" && ! test "${MUTE_MODE}" == "1"; then

    ${MPLEX} -o "${MPEG_OUT}" "${VIDEO_OUT}" "${AUDIO_OUT}"

fi

rm -f ${CQMFILE} ${STATFILE}

exit 0