When you use subprocess, your command must either be a string that looks exactly like what you would type on the command line (and you set shell=True), or a list where each command is an item in the list (and you take the default shell=False). In either case, you have to deal with the variable part of the string. For instance, the operating system has no idea what "%03d" is, you have to fill it in.

I can't tell from your question exactly what the parameters are, but lets assume you want to convert frame 3, it would look something like this in a string:

my_frame = 3
subprocess.call(
    'ffmpeg -r 10 -i frame%03d.png -r ntsc movie%03d.mpg' % (my_frame, my_frame),
    shell=True)

Its kinda subtle in this example, but that's risky. Suppose these things were in a directory whose name name had spaces (e.g., ./My Movies/Scary Movie). The shell would be confused by those spaces.

So, you can put it into a list and avoid the problem

my_frame = 3
subprocess.call([
    'ffmpeg',
    '-r', '10',
    '-i', 'frame%03d.png' % my_frame,
    '-r', 'ntsc',
    'movie%03d.mpg' % my_frame,
])

More typing, but safer.

Simply add ,universal_newlines=True to your subprocess.Popen line.

cmd="ffmpeg -i in.mp4 -y out.avi"
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,universal_newlines=True)
for line in process.stdout:
    print(line)

For now you got line in cycle like:

frame= 1900 fps=453 q=18.6 Lsize=    3473kB time=00:01:16.08 bitrate= 373.9kbits/s

Use the time= value to determine progress in percentage.

For a large directory of movies, I'd use multiprocessing.Pool, to set up a pool workers. Each then converts files using subprocess. I use the following script to do AVI to MKV conversion in batches:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Author: R.F. Smith <[email protected]>
#
# To the extent possible under law, Roland Smith has waived all copyright and
# related or neighboring rights to avi2mkv.py. This work is published from the
# Netherlands. See http://creativecommons.org/publicdomain/zero/1.0/

"""Convert all AVI files found in the direcory trees named on the command line
   to Theora/Vorbis streams in a Matroska container."""

import base64
import os
import sys
import subprocess
from multiprocessing import Pool, Lock

globallock = Lock()

def tempname(ext):
    """Create a name for a temporary file in the /tmp firectory.

    Keyword arguments:
    ext -- the extension (without .) to give to the file.
    """
    return '/tmp/' + base64.b64encode(os.urandom(12), '__') + '.' + ext

def findavi(dirlist):
    """Find AVI files and returns their names in a list.

    Keyword arguments:
    dirlist -- a list of directories to seach in
    """
    result = []
    for dirname in dirlist:
        for root, dirs, files in os.walk(dirname):
            for name in files:
                if name.endswith('.avi'):
                    result.append(root + '/' + name)
    return result

def output(txt):
    """Print while holding a global lock."""
    globallock.acquire()
    print txt
    globallock.release()        

def process(fname):
    """Use ffmpeg2theora and mkvmerge to convert an AVI file to Theora/Vorbis
    streams in a Matroska container.

    Keyword arguments:
    fname -- name of the file to convert
    """
    ogv = tempname('ogv')
    args = ['ffmpeg2theora', '--no-oshash', '-o', ogv, '-v', '7', fname]
    args2 = ['mkvmerge', '-o', fname[:-3] + 'mkv', ogv]
    bitbucket = open('/dev/null')
    try:
        output("Converting {} to {}.".format(fname, ogv))
        subprocess.check_call(args, stdout=bitbucket, stderr=bitbucket)
        output("Starting merge for {}.".format(ogv))
        subprocess.check_call(args2, stdout=bitbucket, stderr=bitbucket)
        os.remove(ogv)
        output("Conversion of {} completed.".format(fname))
    except:
        output("ERROR: Converting {} failed.".format(fname))
    bitbucket.close()

def main(argv):
    """Main program.

    Keyword arguments:
    argv -- command line arguments
    """
    if len(argv) == 1:
        path, binary = os.path.split(argv[0])
        print "Usage: {} [directory ...]".format(binary)
        sys.exit(0)
    avis = findavi(argv[1:])
    p = Pool()
    p.map(process, avis)
    p.close()

if __name__ == '__main__':
    main(sys.argv)

This works fine on my machine (Win10, Blender 2.79, ffmpeg 3.2):

import bpy
import json
import subprocess

def find_video_metadata(video_path: str) -> (int, int):
    """Find the resolution of the input video file."""

    ffpath = r"C:\cygwin64\home\Sybren\ffmpeg\bin\ffprobe.exe"

    args = [ffpath] + "-v quiet -print_format json -show_streams".split() + [video_path]

    # run the ffprobe process, decode stdout into utf-8 & convert to JSON
    ffout = subprocess.check_output(args).decode('utf-8')
    ffinfo = json.loads(ffout)

    # prints all the metadata available:
    import pprint
    pp = pprint.PrettyPrinter(indent=2)
    pp.pprint(ffinfo)

    # for example, find height and width
    height = ffinfo['streams'][0]['height']
    width = ffinfo['streams'][0]['width']

    print(height, width)
    return height, width

fname = r"A:\RIP\prooi\title03.mkv"
print(find_video_metadata(fname))

I've changed a few things:

• Not used shlex to parse the string we construct ourselves. Since you didn't quote the filenames containing the space, my bet is that shlex couldn't split it properly. By avoiding this altogether and constructing the argument list explicitly, it just works.
• Using 'raw' strings using the r"" prefix avoids having to double every backslash.
• I like using different names for different things. I split the doubly-used ffprobeOutput name into ffout (which is a bytes object) and ffinfo (which is a dict).
• Not overriding the built-in name file.
• Using PEP8 for naming (so no camel case for function names and local variable names).
• I added type declarations to the function.
• Turned the comment into a docstring, and removed the "function to" bit of it; the "def" keyword already indicates that it's a function, so there is no need to repeat that.

I would like to understand how to read the following ffmpeg instruction

Your ffmpeg command is semi-obfuscated by scripting so the actual command is not known, but here's an explanation of each option:

• -i indicates the input.
• -r 1 sets output frame rate to 1. This is not needed if you want to output a single image or if you want to output all images. In this example it is used to output one frame per second which would skip many frames.
• -s qvga sets output width x height to "qvga" which is an alias for 320x240.
• -t 1 sets the output duration to 1 second. This is not needed if you want to output a single image or if you want to output all images. It is often added by rookie users trying to output a single image but -frames:v 1 should be used instead.
• -f image2 An often superfluous option used to set the output format or muxer. It is used if your output name is ambiguous (perhaps due to scripting). Otherwise, ffmpeg will automatically choose the proper muxer for image outputs.

how can l adapt it to get all the frames of a given video ?

The simplest, unscripted command to get all of the frames is:

ffmpeg -i input %04d.png

This will output 0001.png, 0002.png, 0003.png, etc. If you want more than a numerical sequence you can use something like output_%05d.png which would result in output_00001.png.

For more info see FFmpeg Documentation: Image Muxer.