83         if frames and args.play:
84             if not ffplay:
85                 cmd = ['ffplay',
86                     '-f', frames[0].format.packed.container_name,
87                     '-ar', str(args.rate or stream.rate),
88                     '-ac', str(len(resampler.layout.channels if resampler else stream.layout.channels)),
89                     '-vn', '-',
90                 ]
91                 print('PLAY', ' '.join(cmd))
92                 ffplay = subprocess.Popen(cmd, stdin=subprocess.PIPE)
93             try:
94                 for frame in frames:
95                     ffplay.stdin.write(frame.planes[0].to_bytes())
96             except IOError as e:
97                 print(e)
98                 exit()

1 #! /bin/sh
2 export LD_LIBRARY_PATH=/usr/lib64:$LD_LIBRARY_PATH
3 
4 /usr/bin/ffplay "$@"

1 me@host: PyAV$ python setup.py build --ffmpeg-dir='ffmpeg-3.2-win64-dev'

1 import sys
2 
3 import av
4 
5 container = av.open(sys.argv[1])
6 for i, frame in enumerate(container.decode(video=0)):
7     frame.to_image().save('sandbox/%04d.jpg' % i)
8     if i > 5:
9         break

 1 # -*- coding: utf-8 -*-
 2 import numpy as np
 3 import av
 4 
 5 duration = 10  # Seconds
 6 frames_per_second = 24
 7 total_frames = duration * frames_per_second
 8 
 9 container = av.open('test.mp4', mode='w')
10 
11 stream = container.add_stream('mpeg4', rate=frames_per_second)
12 stream.width = 480
13 stream.height = 320
14 stream.pix_fmt = 'yuv420p'
15 
16 for frame_i in range(total_frames):
17     img = np.empty((480, 320, 3))
18 
19     img[:, :, 0] = 0.5 + 0.5 * np.sin(frame_i / duration * 2 * np.pi)
20     img[:, :, 1] = 0.5 + 0.5 * np.sin(frame_i / duration * 2 * np.pi + 2 / 3 * np.pi)
21     img[:, :, 2] = 0.5 + 0.5 * np.sin(frame_i / duration * 2 * np.pi + 4 / 3 * np.pi)
22 
23     img = np.round(255 * img).astype(np.uint8)
24 
25     frame = av.VideoFrame.from_ndarray(img, format='rgb24')
26     packet = stream.encode(frame)
27     if packet is not None:
28         container.mux(packet)
29 
30 # Finish encoding the stream -> これすると EOF Error 喰らうんだけどそもそも何をしたい?
31 #while True:
32 #    packet = stream.encode()
33 #    if packet is None:
34 #        break
35 #    container.mux(packet)
36 
37 # Close the file
38 container.close()

 1 # -*- coding: utf-8 -*-
 2 import numpy as np
 3 import av
 4 from tiny_wave_wrapper import WaveReader, WaveWriter
 5 
 6 #
 7 container = av.open("hoge.mp4")
 8 #
 9 stream = next(s for s in container.streams if s.type == 'audio')
10 resampler = av.AudioResampler(
11     format=av.AudioFormat("s16p"), layout="stereo", rate=44100)
12 #
13 
14 # sampwidth=2
15 with WaveWriter("out.wav", 2, 2, 44100) as wavfo:
16     for packet in container.demux(stream):
17         for frame in packet.decode():
18             rf = resampler.resample(frame)
19             channels = (
20                 np.fromstring(rf.planes[0].to_bytes(), dtype=np.int16),
21                 np.fromstring(rf.planes[1].to_bytes(), dtype=np.int16))
22             wavfo.writechannels(channels)

 1 from io import BytesIO
 2 import math
 3 import numpy as np
 4 import av
 5 from pytinymts.scales import onsc2freq
 6 from tiny_wave_wrapper import WaveReader, WaveWriter
 7 
 8 _RATE = 44100
 9 _SAMPW = 2
10 
11 # ---
12 # setup PCM data
13 maxvol = 2**10 - 1.0  #maximum amplitude
14 _score = [
15     [  # left channel
16         # (duration, ((octave number 1, scale 1), ...))
17         (8, ((5, "C"), (5, "E"), (5, "G"))),  # C
18         (8, ((5, "D"), (5, "F"), (5, "A"))),  #
19         ],
20     [  # right channel
21         (1, ((6, "C"),)), (1, ((6, "E"),)), (1, ((6, "G"),)),
22         (1, ((6, "E"),)), (4, ((6, "C"),)),
23         (1, ((6, "D"),)), (1, ((6, "F"),)), (1, ((6, "A"),)),
24         (1, ((6, "F"),)), (4, ((6, "D"),)),
25         ]
26     ]
27 pcm = [[], []]
28 for chn, scorech in enumerate(_score):
29     for dur, chord in scorech:
30         for i in range(0, dur * _RATE):
31             pcm[chn].append(
32                 int(maxvol * sum(
33                     [math.sin(i * math.pi * 2 * onsc2freq(on, sc) / _RATE)
34                      for on, sc in chord]) / len(chord)))
35 
36 tmp = BytesIO()
37 with WaveWriter(tmp, 2, 2, 44100) as wavfo:
38     wavfo.writechannels(pcm)
39 tmp.seek(0)
40 
41 # ---
42 # write as aac with av
43 tcont = av.open(tmp, "r")
44 tstr = next(s for s in tcont.streams if s.type == 'audio')
45 ocont = av.open("test_CEG.aac", "w")
46 resampler = av.AudioResampler(
47     format=av.AudioFormat("fltp"), layout="stereo", rate=_RATE)
48 astream = ocont.add_stream(codec_name='aac', rate=_RATE)
49 for packet in tcont.demux(tstr):
50     for frame in packet.decode():
51         rf = resampler.resample(frame)
52         p = astream.encode(rf)
53         if p is not None:
54             ocont.mux(p)

 1 from io import BytesIO
 2 import math
 3 import numpy as np
 4 import matplotlib.pyplot as plt
 5 import av
 6 from pytinymts.scales import onsc2freq
 7 from tiny_wave_wrapper import WaveReader, WaveWriter
 8 
 9 _ARATE = 44100
10 _SAMPW = 2
11 
12 # ---
13 # setup PCM data
14 maxvol = 2**10 - 1.0  #maximum amplitude
15 _score = [
16     [  # left channel
17         # (duration, ((octave number 1, scale 1), ...))
18         (8, ((5, "C"), (5, "E"), (5, "G"))),  # C
19         (8, ((5, "D"), (5, "F"), (5, "A"))),  #
20         ],
21     [  # right channel
22         (1, ((6, "C"),)), (1, ((6, "E"),)), (1, ((6, "G"),)),
23         (1, ((6, "E"),)), (4, ((6, "C"),)),
24         (1, ((6, "D"),)), (1, ((6, "F"),)), (1, ((6, "A"),)),
25         (1, ((6, "F"),)), (4, ((6, "D"),)),
26         ]
27     ]
28 pcm = [[], []]
29 for chn, scorech in enumerate(_score):
30     for dur, chord in scorech:
31         for i in range(0, dur * _ARATE):
32             pcm[chn].append(
33                 int(maxvol * sum(
34                     [math.sin(i * math.pi * 2 * onsc2freq(on, sc) / _ARATE)
35                      for on, sc in chord]) / len(chord)))
36 
37 tmp = BytesIO()
38 with WaveWriter(tmp, 2, 2, 44100) as wavfo:
39     wavfo.writechannels(pcm)
40 tmp.seek(0)
41 
42 # ---
43 # write as mp4 with av
44 tcont = av.open(tmp, "r")
45 tstr = next(s for s in tcont.streams if s.type == 'audio')
46 ocont = av.open("test_av_audiovideomux.mp4", "w")
47 resampler = av.AudioResampler(
48     format=av.AudioFormat("fltp"), layout="stereo", rate=_ARATE)
49 astream = ocont.add_stream(codec_name='aac', rate=_ARATE)
50 vstream = None
51 for packet in tcont.demux(tstr):
52     for frame in packet.decode():
53         #
54         # mux audio packets
55         rf = resampler.resample(frame)
56         p = astream.encode(rf)
57         if p is not None:
58             ocont.mux(p)
59         #
60         # mux video packets
61         fig, ax = plt.subplots()
62         ax2 = plt.subplot(1, 2, 1)
63         left = np.fromstring(rf.planes[0].to_bytes(), dtype=np.float32)
64         ax2.plot(left)
65         ax2.set_ylim((-0.03, 0.03))
66         ax2 = plt.subplot(1, 2, 2)
67         right = np.fromstring(rf.planes[1].to_bytes(), dtype=np.float32)
68         ax2.plot(right)
69         ax2.set_ylim((-0.03, 0.03))
70         fig.canvas.draw()
71         ncols, nrows = fig.canvas.get_width_height()
72         rgb = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8).reshape(nrows, ncols, 3)
73         plt.close(fig)
74         if vstream is None:
75             vrate = int(_ARATE // left.size)
76             vstream = ocont.add_stream('mpeg4', rate=vrate)
77             vstream.width = ncols
78             vstream.height = nrows
79             vstream.pix_fmt = 'yuv420p'
80 
81         vframe = av.VideoFrame.from_ndarray(rgb, format='rgb24')
82         p = vstream.encode(vframe)
83         if p is not None:
84             ocont.mux(p)
85 ocont.close()  # MUST!

 1 # ... 省略 ...
 2         #
 3         # mux audio packets
 4         rf = resampler.resample(frame)
 5         for p in astream.encode(rf):
 6             ocont.mux(p)
 7 # ... 省略 ...
 8         for p in vstream.encode(vframe):
 9             ocont.mux(p)
10 # ... 省略 ...

 1 import av
 2 import argparse
 3 
 4 if __name__ == '__main__':
 5     parser = argparse.ArgumentParser()
 6     parser.add_argument("inputpath")
 7     parser.add_argument("start_sec", type=float)
 8     args = parser.parse_args()
 9 
10     icont = av.open(args.inputpath)
11     ocont = av.open(args.inputpath + ".out.mp4", "w")
12     in_to_out = {}
13     for i, s in enumerate(icont.streams):
14         if s.type in (b'audio', b'video', b'subtitle', b'data'):
15             in_to_out[s] = ocont.add_stream(template=s)
16 
17     #ivstr = next(s for s in icont.streams if s.type == b'video')
18     #iastr = next(s for s in icont.streams if s.type == b'audio')
19 
20     #seek_pts_v = int(args.start_sec / float(ivstr.time_base) + ivstr.start_time)
21     #seek_pts_a = int(args.start_sec / float(iastr.time_base) + iastr.start_time)
22 
23     #iastr.seek(seek_pts_a, any_frame=True)
24     for i, packet in enumerate(icont.demux(in_to_out.keys())):
25         if packet.dts is None:
26             continue
27         packet.stream = in_to_out[packet.stream]
28         ocont.mux(packet)
29     ocont.close()
30 
31 #    print(seek_pts_v, seek_pts_a)
32 #
33 #    iastr.seek(seek_pts_a, any_frame=True)
34 #    oastr = ocont.add_stream(codec_name='aac', rate=iastr.average_rate)
35 #    seek_pts_a = None
36 #    for packet in icont.demux(iastr):
37 #        #if packet.dts is None:
38 #        #    continue
39 #        for iframe in packet.decode():
40 #            iframe.pts = None
41 #            for p in oastr.encode(iframe):
42 #                ocont.mux(p)
43 #
44 #    ivstr.seek(seek_pts_v, any_frame=True)
45 #    ovstr = ocont.add_stream(codec_name='h264', rate=ivstr.average_rate)
46 #    for packet in icont.demux(ivstr):
47 #        if packet.dts is None:
48 #            continue
49 #        for iframe in packet.decode():
50 #            iframe.pts = None
51 #            for p in ovstr.encode(iframe):
52 #                try:
53 #                    ocont.mux(p)
54 #                except ValueError:
55 #                    pass
56 #
57 #    ocont.close()

 1 import av
 2 import argparse
 3 
 4 if __name__ == '__main__':
 5     parser = argparse.ArgumentParser()
 6     parser.add_argument("inputpath")
 7     parser.add_argument("start_sec", type=float)
 8     args = parser.parse_args()
 9 
10     icont = av.open(args.inputpath)
11     ocont = av.open(args.inputpath + ".out.mp4", "w")
12     in_to_out = {}
13     for i, s in enumerate(icont.streams):
14         if s.type in (b'audio', b'video', b'subtitle', b'data'):
15             in_to_out[s] = ocont.add_stream(template=s)
16 
17     ivstr = next(s for s in icont.streams if s.type == b'video')
18     iastr = next(s for s in icont.streams if s.type == b'audio')
19 
20     seek_pts_v = int(args.start_sec / float(ivstr.time_base) + ivstr.start_time)
21     seek_pts_a = int(args.start_sec / float(iastr.time_base) + iastr.start_time)
22 
23     iastr.seek(seek_pts_a)
24     ivstr.seek(seek_pts_v)
25     for i, packet in enumerate(icont.demux(in_to_out.keys())):
26         if packet.dts is None:
27             continue
28         packet.stream = in_to_out[packet.stream]
29         ocont.mux(packet)
30     ocont.close()

 1 import argparse
 2 import av
 3 import av.filter
 4 
 5 if __name__ == '__main__':
 6     parser = argparse.ArgumentParser()
 7     parser.add_argument("inputpath")
 8     args = parser.parse_args()
 9 
10     icntnr = av.open(args.inputpath)
11     ocntnr = av.open(args.inputpath + ".out.mp4", "w")
12 
13     ivstrm = next(s for s in icntnr.streams if s.type == b'video')
14     iastrm = next(s for s in icntnr.streams if s.type == b'audio')
15     ostrms = {
16         "audio": ocntnr.add_stream(codec_name="aac", rate=iastrm.sample_rate),
17         "video": ocntnr.add_stream(codec_name="h264", rate=ivstrm.average_rate),
18         }
19 
20     graph = av.filter.Graph()
21     # you can enumerate available filters with av.filter.filters_available.
22     #print(av.filter.filters_available)
23     #
24     fchain = {"video": [], "audio": []}
25     fchain["video"].append(graph.add_buffer(template=ivstrm))
26     fchain["video"].append(graph.add("vflip"))
27     fchain["video"][-2].link_to(fchain["video"][-1])
28     fchain["video"].append(graph.add("buffersink"))
29     fchain["video"][-2].link_to(fchain["video"][-1])
30 
31     fchain["audio"].append(graph.add_abuffer(template=iastrm))
32     #fchain["audio"].append(graph.add("aecho", "0.8:0.9:1000|1800:0.3|0.25"))
33     fchain["audio"].append(graph.add("volume", "3.0"))
34     fchain["audio"][-2].link_to(fchain["audio"][-1])
35     fchain["audio"].append(graph.add("abuffersink"))
36     fchain["audio"][-2].link_to(fchain["audio"][-1])
37 
38     for packet in icntnr.demux():
39         for ifr in packet.decode():
40             typ = packet.stream.type
41             fchain[typ][0].push(ifr)
42             ofr = fchain[typ][-1].pull()
43             ofr.pts = None
44             for p in ostrms[typ].encode(ofr):
45                 ocntnr.mux(p)
46 
47     ocntnr.close()

146     def push(self, frame):
147 
148         if isinstance(frame, VideoFrame):
149             contexts = self._context_by_type.get('buffer', [])
150         elif isinstance(frame, AudioFrame):                      # ADD
151             contexts = self._context_by_type.get('abuffer', [])  # ADD
152         else:
153             raise ValueError('can only push VideoFrame or AudioFormat', type(frame))
154        # ...