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.

We may add double quotes for letting Python subprocess know the string is one argument, and we have to close FFmpeg gracefully.

Adding double quotes:
Replace the following part video="HP HD Camera":audio="Headset (realme Buds Wireless 2 Neo Hands-Free AG Audio)" with:
"video=""HP HD Camera"":audio=""Headset (realme Buds Wireless 2 Neo Hands-Free AG Audio)"""
Doubling the quotes "" is required because " is between quotes " ... ".

We may also use it without the "": "video=HP HD Camera:audio=Headset (realme Buds Wireless 2 Neo Hands-Free AG Audio)".

For getting a playable file, we have to close FFmpeg gracefully.
For simply recording 10 seconds, we may add -t 10 argument.

For closing FFmpeg gracefully programmatically, we may write 'q'.encode("GBK") to stdin pipe of FFmpeg sub-process.
Writing q simulates that q key is pressed by the user (stop recording).

• Add stdin=subprocess.PIPE argument to subprocess.Popen.

• After time.sleep(10) add:

   recorder.stdin.write('q'.encode("GBK"))  # Simulate user pressing q key
   recorder.communicate()
  

• Add recorder.wait() (instead of recorder.terminate() and recorder.kill()).

As good practice we may also add shlex.split(...) for converting the command line to a list of arguments.
In Windows it supposed to work without it, but in Linux it's not.

Code sample:

import subprocess, time, shlex

recorder = subprocess.Popen(shlex.split('ffmpeg -f dshow -rtbufsize 2000M -t 60 -i """video=HP HD Camera:audio=Headset (realme Buds Wireless 2 Neo Hands-Free AG Audio)"":""audio=Headset (realme Buds Wireless 2 Neo Hands-Free AG Audio)"""'
                                        ' -y -vcodec libx264 -crf 24 output.mp4'), stdin=subprocess.PIPE, shell=False)

time.sleep(10)

recorder.stdin.write('q'.encode("GBK"))  # Simulate user pressing q key
recorder.communicate()
recorder.wait()

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.

Linux/Unix solution:

import subprocess, os, signal
# ...
# Start the task:
proc = subprocess.Popen(..., start_new_session=True)
# ...
def send_signal_to_task(pid, signal):
        #gpid = os.getpgid(pid)  # WARNING This does not work
        gpid = pid  # But this does!
        print(f"Sending {signal} to process group {gpid}...")
        os.killpg(gpid, signal)
# ...
# Pause and resume:
send_signal_to_task(proc.pid, signal.SIGSTOP)
send_signal_to_task(proc.pid, signal.SIGCONT)

Notice start_new_session=True in Popen call and using of os.killpg instead of os.kill in send_signal_to_task function. The reason for this is the same as as reason for why you have large CPU usage even in paused state as you reported. ffmpeg spawns a number of child processes. start_new_session=True will create a new process group and os.killpg sends signal to all processes in group.

Cross-platform solution is supposed to be provided by psutil module but you probably should research whether it supports process groups as the variant above:

>>> import psutil
>>> psutil.pids()
[1, 2, 3, 4, 5, 6, 7, 46, 48, 50, 51, 178, 182, 222, 223, 224, 268, 1215,
 1216, 1220, 1221, 1243, 1244, 1301, 1601, 2237, 2355, 2637, 2774, 3932,
 4176, 4177, 4185, 4187, 4189, 4225, 4243, 4245, 4263, 4282, 4306, 4311,
 4312, 4313, 4314, 4337, 4339, 4357, 4358, 4363, 4383, 4395, 4408, 4433,
 4443, 4445, 4446, 5167, 5234, 5235, 5252, 5318, 5424, 5644, 6987, 7054,
 7055, 7071]
>>> p = psutil.Process(7055)
>>> p.suspend()
>>> p.resume()

Reference: https://pypi.org/project/psutil/

Some pointers on emulating process groups in Windows: Popen waiting for child process even when the immediate child has terminated

Put each argument in its own string and turn off the shell. Like this:

import subprocess
import os

cmd = ["-f", "gdigrab", "-offset_x", "10", "-offset_y", "20",
    "-show_region", "1", "-video_size", "1536x864", "-i", "desktop",
    "-b:v", "2M", "-maxrate", "1M", "-bufsize", "1M", "-tune", "fastdecode",
    "-preset", "ultrafast", "-pix_fmt", "yuv420p",
    "-r", "25", "-qp", "1", "-y", "-an",
    os.path.join(path, "video.mov")]

p = subprocess.Popen([getPathForFile("windows/ffmpeg")]+cmd)
p.communicate()

I am doing ffmpeg through subprocess like this:

1.) ffmpeg command as string instead of list.
2.) Double quotes for -vf options.
3.) shell=True.
4.) -y to force ffmpeg to overwrite the new file.
5.) ffmpeg version 3.4 on Python 2.7/Python3.6.

cmd = "ffmpeg -threads %s -i %s " % (_threads, _videoFile['path'])
for fmt in ('640:360', '1024:576'):
    cmd += ' ... alot of string concentration here ...' 

print "ffmpeg command is:"
print cmd
print ""

cmd = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
out, err = cmd.communicate()
if cmd.returncode == 0 and all([os.path.exists(f) for f in (videoStorage['data_small'], videoStorage['data_big'])]):
    print "Job done."
else:
    print "ERROR"
    print out

Output:

ffmpeg command is:
ffmpeg -threads 2 -i /home/f3k/mini.elapsed.mov    -to 0:00:41   -vf "boxblur=enable='between(t,5.646,23.353)'"  -s 640:360 -sn -codec:a copy -q:v 1 -threads 2 -y /tmp/result.small.mp4    -to 0:00:41   -vf "boxblur=enable='between(t,5.646,23.353)'"  -s 1024:576 -sn -codec:a copy -q:v 1 -threads 2 -y /tmp/result.big.mp4 

Job done.

Instead of adding -nosdtin, avoid using shell=True when opening FFmpeg subprocess.

Python code sample:

import subprocess as sp
import shlex
import psutil
from time import sleep

# Open FFmpeg subprocess with opened stdin pipe (generate synthetic pattern for testing):
process = sp.Popen(shlex.split('ffmpeg -hide_banner -y -re -f lavfi -i testsrc=size=384x216:rate=1 -c:v libx264 -pix_fmt yuv420p test.mp4'), stdin=sp.PIPE)
ps_process = psutil.Process(pid=process.pid)  # Pass the PID of FFmpeg subprocess to PsUtil.

sleep(3)  # Wait 3 seconds for testing ("recored 3 seconds")
ps_process.suspend()  # Suspend FFmpeg process for 3 seconds
sleep(3)  # Wait 3 seconds
ps_process.resume()  # Resume FFmpeg process.
sleep(3)
ps_process.suspend()
sleep(3)
ps_process.resume()

# Close FFmpeg gracefully:
process.stdin.write(b'q')  # Simulate user pressing q key for gracefully closing FFmpeg.
process.communicate()
process.wait()

In Linux, when using: process = sp.Popen(shlex.split('ffmpeg ...'), stdin=sp.PIPE, shell=True), I am getting the following message usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}... and Use -h to get full help or, even better, run 'man ffmpeg'.