Can someone post the conversion software and settings for long video?

Howdy,

I've been struggling with the M6 for probably about 10-12 hours now (time spent trying to convert video). I found the faq's for converting video, but then struggled for quite a while with an audio sync problem. I've finally got that somewhat resolved (by offsetting the audio 100ms in Iriverter or 250ms in Virtual Dub), but now I'm having the "fast forward" problem.

When playing a video over an hour in length, fast forward goes - well - wonky. It throws in random characters into the time index which when fast forward is released, then kick the M6 out of video playback and back to the list of videos. If I continue to hold down the FF button (as suggested by one user) it eventually begins working normally - but drops you back into the video some hour + down the line - thereby making it fairly useless.

Can someone who has gotten long videos to play correctly (ie working fast forward, sync, etc...) perhaps post and just let me know what your settings are and the program you are using?

I've had the "best" luck with Virtual Dub, but just have to overcome this fast forward issue. I'm hoping it's not a problem with the firmware on the M6, rather something that I can solve with a simple change of the video conversion settings.

I'm running firmware S 2.002.3, and I currently have 1.91 gb free on the player. On the software side, I'm running VirtualDub-MPEG2 1.6.15 build 24600.

(I've tried Badak, Iriverter, the conversion software that came on the CD, the updated conversion software downloaded from the Meizu website, Media Coder and a couple of other utilities. I keep coming back to Virtual Dub as that seems to give the best overall results and allow for the most tweaks.)

TIA

Good settings for video:

Video Bitrate: 394
Audio: 128
FPS: 20

(20 - 30 min segments)

Windows:

Not sure what application you will do this for you but you basically need to chop the movie in segments of 20-30 minutes each.. I personally use 30 minutes. Then convert each segment.

Linux:

Thanks to parena for this (www.parena.net).

In command line type:

Code:

sudo nano /usr/bin/meizu-prepare

Then put this in and save:

Code:

#!/bin/bash
VBITRATE=192
LENGTH=20
TARGETDIR=`pwd`
FILELIST=''

function usage() {
    echo "Usage: meizu_prepare [ flags ] [ file1 ] [ file2 ] [ etc. ]"
    echo
    echo "Flags:"
    echo "    -vbitrate n"
    echo "     Set the vbitrate. Defaults to 192."
    echo "    -length n"
    echo "     Set the length of each part in minutes. Defaults to 20."
    echo "    -targetdir path"
    echo "     Set the destination directory. Missing directories will"
    echo "     be created. Defaults to current directory."
    echo
    exit
}

# Not enough arguments
if [[ $# -lt 1 ]]; then
    echo
    echo "Not enough arguments. You must at least give one file to prepare!"
    echo
    usage
fi

index=0
flagged=0
fileflagged=0

for arg in $* ; do
    if [[ $flagged -eq 0 ]]; then
        case "${arg}" in
            -targetdir)
                curarg=$arg
                flagged=1
            ;;

            -length)
                curarg=$arg
                flagged=1
            ;;

            -vbitrate)
                curarg=$arg
                flagged=1
            ;;

            *)
                if [[ ${arg:(-4)} == ".avi" || ${arg:(-4)} == ".mov" || ${arg:(-4)} == ".mpg" ]]; then
                    if [[ -f $arg ]]; then
                        (( index++ ))
                        FILELIST[$index]=$arg
                    else
                        if [[ $fileflagged -eq 0 ]]; then
                            (( index++ ))
                        else
                            fileflagged=0
                        fi
                        FILELIST[$index]="${FILELIST[${index}]} ${arg}"
                        fileflagged=0
                    fi
                else
                    if [[ $fileflagged -eq 0 ]]; then
                        (( index++ ))
                        FILELIST[$index]="${arg}"
                    else
                        FILELIST[$index]="${FILELIST[${index}]} ${arg}"
                    fi
                    fileflagged=1
                fi
            ;;
        esac
    elif [[ $flagged -eq 1 ]]; then
        case "${curarg}" in
            -targetdir)
                TARGETDIR=$arg
                flagged=0
            ;;

            -length)
                if [[ $arg -gt 60 ]]; then
                    echo
                    echo "error: length cannot be longer than 60 minutes"
                    echo
                    exit
                elif [[ $arg -lt 1 ]]; then
                    echo
                    echo "error: length cannot be shorter than 1 minute"
                    echo
                    exit
                else
                    LENGTH=$arg
                fi
                flagged=0
            ;;

            -vbitrate)
                case "${arg}" in
                    394)
                        VBITRATE=${arg}
                    ;;
                    256)
                        VBITRATE=${arg}
                    ;;
                    192)
                        VBITRATE=${arg}
                    ;;
                    128)
                        VBITRATE=${arg}
                    ;;
                    *)
                        echo
                        echo "error: vbitrate can only by 394, 256, 192 or 128"
                        echo
                        exit
                    ;;
                esac
                flagged=0
            ;;

            *)
                usage
            ;;
        esac
    fi
done

PARTLENGTH=`expr ${LENGTH} \* 60`

clear

echo "Storing videos in ${TARGETDIR} ..."

for ((i=1;i<=$index;i++)); do
    file=${FILELIST[${i}]}
    TARGETFILENAME=`echo "${file}" | sed 's/.*\///g' | sed 's/ /_/g' | sed 's/\./#/g' | awk -F# '{print $1}'`

    if [[ ! -d $TARGETDIR ]]; then
        mkdir --parents $TARGETDIR
    fi
    TARGET=$TARGETDIR/$TARGETFILENAME

    if [[ $TARGETDIR == `pwd` ]]; then
        if [[ "${TARGETFILENAME}.avi" == "${file}" ]]; then
            echo
            echo "Source and destination file are the same!"
            echo
            exit
        fi
    fi

    echo

    FILELENGTH=`echo q | mplayer -identify "${file}" | grep ID_LENGTH | cut -c11- | sed 's/\..*//g'`

    MINUTES=`expr ${FILELENGTH} / 60`
    SECONDS=`expr ${FILELENGTH} % 60`

    if [ ${MINUTES} -gt 60 ]; then
        HOURS=`expr ${MINUTES} / 60`
        MINUTES=`expr ${MINUTES} % 60`
    fi

    PARTS=`expr $FILELENGTH / ${PARTLENGTH} + 1`
    LASTPART=`expr $FILELENGTH % ${PARTLENGTH}`

    echo
    echo "Splitting ${file} into ${PARTS} parts:";
    echo

    PART=0
    while [ ${PART} -lt ${PARTS} ]; do
        if [ ${PART} -gt 0 ]; then
            ENC_LENGTH=`expr ${PART} \* ${PARTLENGTH}`
            ENC_MINUTES=`expr ${ENC_LENGTH} / 60`
            ENC_SECONDS=`expr ${ENC_LENGTH} % 60`
            
            if [ ${ENC_MINUTES} -gt 60 ]; then
                ENC_HOURS=`expr ${ENC_MINUTES} / 60`
                ENC_MINUTES=`expr ${ENC_MINUTES} % 60`
            else
                ENC_HOURS=0
            fi

            if [ ${ENC_MINUTES} -lt 10 ]; then
                ENC_MINUTES=0${ENC_MINUTES}
            fi

            ENC_START=${ENC_HOURS}:${ENC_MINUTES}:00
        else
            ENC_START=0:00:00
        fi

        # Counter goes up for nice naming of the output file
        PART=`expr ${PART} + 1`

        if [ ${PARTS} -gt 1 ]; then
            PARTEXT=_${PART}
        else
            PARTEXT=''
        fi

        echo "`date +%H:%M:%S` Encoding part ${PART}/${PARTS}: ${TARGETFILENAME}${PARTEXT}.avi at ${ENC_START}"

        mencoder "${file}" -idx -noodml -ofps 20 -vf \
                 scale=320:-2,expand=:240:::1,crop=320:240,rotate=1 \
                 -ovc lavc -ffourcc XVID -lavcopts \
                 vcodec=mpeg4:vbitrate=${VBITRATE}:vmax_b_frames=0:vhq \
                 -sws 9 -srate 44100 -oac mp3lame -lameopts \
                 cbr:br=128:mode=0 -ss ${ENC_START} -endpos 0:${LENGTH}:00 \
                 -o "${TARGET}${PARTEXT}.avi" &> /dev/null
     
    done
    echo "`date +%H:%M:%S` Encoding finished ..."
    echo
done

Then make it executable:

Code:

sudo chmod +x /usr/bin/meizu-prepare

Then type meizu-prepare in the command line for syntax.

I spent a couple of days and god knows how many conversions trying various adjustments in VDub to try and get around the fast forward problem with long movies and found no solution other than using the save file as "Segmented AVI" option and splitting it in half. I concluded that the problem is firmware based.

However I have been using CloneDVDMobile to rip my DVD's to AVI before putting them through VDub for sizing, cropping etc. Today I messed with the predefined device profiles in CloneDVDMobile to create a profile for the M6 and managed to rip the same DVD (2 Hours and 6 Minutes playtime) and it fast forwards with no problem. I then ripped a 2 hour 23 Minute DVD and that did not have the FF problem either so it may be a conversion problem.

Even better is it now a one step process takes around 30 minutes to rip a DVD and it is good to go.

I posted the Devices.ini with the M6 profile here: Quick & Dirty One-Step DVD>M6 video conversion