اعمل فيديو اغنية اطفال مدته دقيقة

python
import os, subprocess, shutil, sys, textwrap, json, math, wave
print("ffmpeg:", shutil.which("ffmpeg"))
print("espeak:", shutil.which("espeak") or shutil.which("espeak-ng"))

python
import subprocess, re, os, textwrap, json, shutil
out = subprocess.run(["espeak","--voices"], capture_output=True, text=True).stdout
arabic = [line for line in out.splitlines() if " ar " in (" "+line+" ") or "arabic" in line.lower()]
print("\n".join(arabic[:10]) if arabic else "No explicit Arabic voice listed")

python
import subprocess, os, shutil, textwrap
test = subprocess.run(["espeak","-v","ar","مرحبا"], capture_output=True, text=True)
print("returncode:", test.returncode)
print((test.stderr or test.stdout)[:300])

python
from PIL import features, ImageFont
import subprocess, os, glob, textwrap, json, sys
print("raqm:", features.check("raqm"))
fonts = subprocess.run(["fc-list",":lang=ar","family","file"],capture_output=True,text=True).stdout.splitlines()
print("\n".join(fonts[:8]))

python
import os, math, wave, subprocess, shutil, textwrap, numpy as np
from PIL import Image, ImageDraw, ImageFont

out_dir = "/mnt/data"
os.makedirs(out_dir, exist_ok=True)
wav_path = os.path.join(out_dir, "kids_colors_music.wav")
mp4_path = os.path.join(out_dir, "kids_colors_song_60s.mp4")

# -----------------------------
# 1) Create a cheerful 60s instrumental track
# -----------------------------
sr = 44100
duration = 60.0
n = int(sr * duration)
audio = np.zeros(n, dtype=np.float64)

note_freq = {
    "C4":261.63,"D4":293.66,"E4":329.63,"F4":349.23,"G4":392.00,"A4":440.00,"B4":493.88,
    "C5":523.25,"D5":587.33,"E5":659.25,"G5":783.99
}

# 120 BPM, eighth-note grid
step = 0.25
melody = [
    "C4","E4","G4","E4","D4","F4","A4","F4",
    "E4","G4","C5","G4","G4","E4","D4","C4",
    "C4","E4","G4","C5","B4","G4","E4","D4",
    "F4","A4","C5","A4","G4","E4","D4","C4",
]
melody = melody * int(math.ceil(duration / (len(melody)*step)))

def add_tone(start, dur, freq, amp=0.18, kind="bell"):
    i0 = int(start*sr)
    i1 = min(n, int((start+dur)*sr))
    if i1 <= i0: return
    t = np.arange(i1-i0)/sr
    # soft attack/release
    env = np.ones_like(t)
    a = min(int(0.02*sr), len(t)//4)
    r = min(int(0.08*sr), len(t)//3)
    if a > 0:
        env[:a] = np.linspace(0,1,a)
    if r > 0:
        env[-r:] *= np.linspace(1,0,r)
    if kind == "bell":
        sig = (np.sin(2*np.pi*freq*t) +
               0.35*np.sin(2*np.pi*2*freq*t) +
               0.12*np.sin(2*np.pi*3*freq*t))
        sig *= np.exp(-2.3*t/max(dur,0.01))
    else:
        sig = np.sin(2*np.pi*freq*t)
    audio[i0:i1] += amp * env * sig

# melody
for k, note in enumerate(melody):
    st = k*step
    if st >= duration: break
    add_tone(st, 0.22, note_freq[note], 0.14, "bell")

# chord pad per 2 sec
chords = [
    ("C4","E4","G4"), ("F4","A4","C5"), ("G4","B4","D5"), ("C4","E4","G4")
]
for bar_start in np.arange(0, duration, 2.0):
    chord = chords[int(bar_start/2) % len(chords)]
    for note in chord:
        add_tone(bar_start, 1.9, note_freq[note], 0.035, "sine")

# kick + clap-ish percussion
rng = np.random.default_rng(7)
for beat in np.arange(0, duration, 0.5):
    i0 = int(beat*sr)
    L = int(0.12*sr)
    if i0+L < n:
        t = np.arange(L)/sr
        kick = np.sin(2*np.pi*(85 - 45*t/0.12)*t) * np.exp(-30*t)
        audio[i0:i0+L] += 0.11*kick
for clap_t in np.arange(0.5, duration, 1.0):
    i0 = int(clap_t*sr)
    L = int(0.06*sr)
    if i0+L < n:
        t = np.arange(L)/sr
        noise = rng.normal(0,1,L) * np.exp(-55*t)
        audio[i0:i0+L] += 0.035*noise

# normalize and make stereo
peak = np.max(np.abs(audio))
audio = audio / max(peak, 1e-9) * 0.82
stereo = np.stack([audio, audio], axis=1)
pcm = (stereo * 32767).astype(np.int16)
with wave.open(wav_path, "wb") as wf:
    wf.setnchannels(2)
    wf.setsampwidth(2)
    wf.setframerate(sr)
    wf.writeframes(pcm.tobytes())

# -----------------------------
# 2) Render cartoon lyric video
# -----------------------------
W, H = 960, 540
fps = 12
font_path = "/usr/share/fonts/truetype/noto/NotoSansArabic-CondensedSemiBold.ttf"
font_bold_path = "/usr/share/fonts/truetype/noto/NotoKufiArabic-ExtraBold.ttf"
font_title = ImageFont.truetype(font_bold_path, 54)
font_lyric = ImageFont.truetype(font_path, 42)
font_small = ImageFont.truetype(font_path, 28)

scenes = [
    (0,10, (255,230,235), ["هيا هيا يا أصدقاء","نرسم لونًا في السماء","أحمر أحمر مثل التفاح","نضحك نلعب بانشراح"], "red"),
    (10,20,(255,246,188), ["أصفر أصفر مثل الشمس","نورٌ دافئ مثل الهمس","فوق الزهور نحلة تطير","تضحك معنا يا صغير"], "yellow"),
    (20,30,(217,246,218), ["أخضر أخضر لون الشجر","والعشب الجميل انتشر","أرنب يجري في البستان","يقفز فرحًا في كل مكان"], "green"),
    (30,40,(210,237,255), ["أزرق أزرق لون البحار","فوقه تطير لنا الأطيار","سمكة تسبح: هيا هيا","نغني سويًا يا أحبابي"], "blue"),
    (40,50,(244,226,255), ["أحمر أصفر أخضر أزرق","كل الألوان تجعلنا نضحك","نصفق مرة، نقفز مرتين","وندور حول أنفسنا اثنتين"], "mix"),
    (50,60,(255,238,206), ["ألوان ألوان يا سلام","تملأ بالفرحة كل الأيام","هيا نغني من جديد","يومٌ جميل ويومٌ سعيد!"], "rainbow"),
]

def rounded_rect(draw, box, radius, fill, outline=None, width=1):
    draw.rounded_rectangle(box, radius=radius, fill=fill, outline=outline, width=width)

def draw_cloud(draw, x, y, s=1.0):
    c=(255,255,255)
    draw.ellipse((x,y,x+70*s,y+42*s), fill=c)
    draw.ellipse((x+25*s,y-18*s,x+85*s,y+40*s), fill=c)
    draw.ellipse((x+55*s,y,x+120*s,y+44*s), fill=c)

def draw_sun(draw, x, y, r=48):
    for a in range(0,360,45):
        ang=math.radians(a)
        x1=x+math.cos(ang)*(r+10); y1=y+math.sin(ang)*(r+10)
        x2=x+math.cos(ang)*(r+28); y2=y+math.sin(ang)*(r+28)
        draw.line((x1,y1,x2,y2), fill=(255,186,40), width=6)
    draw.ellipse((x-r,y-r,x+r,y+r), fill=(255,215,70), outline=(244,170,30), width=4)
    draw.ellipse((x-15,y-7,x-8,y), fill=(60,60,60))
    draw.ellipse((x+8,y-7,x+15,y), fill=(60,60,60))
    draw.arc((x-18,y-2,x+18,y+20), 10,170, fill=(80,80,80), width=3)

def draw_apple(draw, x, y, s=1.0):
    draw.ellipse((x-35*s,y-28*s,x+8*s,y+24*s), fill=(235,55,65))
    draw.ellipse((x-5*s,y-28*s,x+38*s,y+24*s), fill=(245,70,80))
    draw.rectangle((x-2*s,y-48*s,x+4*s,y-25*s), fill=(110,75,40))
    draw.ellipse((x+2*s,y-48*s,x+24*s,y-32*s), fill=(70,180,80))

def draw_bee(draw, x, y, s=1.0):
    draw.ellipse((x-34*s,y-20*s,x+34*s,y+20*s), fill=(255,205,40), outline=(80,65,30), width=2)
    for dx in (-15,5):
        draw.rectangle((x+dx*s,y-19*s,x+(dx+7)*s,y+19*s), fill=(60,60,60))
    draw.ellipse((x-20*s,y-36*s,x+2*s,y-10*s), fill=(235,250,255), outline=(120,170,190))
    draw.ellipse((x+4*s,y-36*s,x+26*s,y-10*s), fill=(235,250,255), outline=(120,170,190))
    draw.ellipse((x+22*s,y-6*s,x+27*s,y-1*s), fill=(30,30,30))

def draw_tree(draw, x, y, s=1.0):
    draw.rectangle((x-18*s,y,x+18*s,y+95*s), fill=(135,90,45))
    for dx,dy,r in [(-45,-25,42),(0,-45,52),(45,-20,40),(0,0,45)]:
        draw.ellipse((x+(dx-r)*s,y+(dy-r)*s,x+(dx+r)*s,y+(dy+r)*s), fill=(70,180,90), outline=(45,145,70))

def draw_bunny(draw, x, y, s=1.0):
    body=(245,245,245)
    draw.ellipse((x-28*s,y-35*s,x+28*s,y+28*s), fill=body, outline=(160,160,160))
    draw.ellipse((x-24*s,y-92*s,x-4*s,y-30*s), fill=body, outline=(160,160,160))
    draw.ellipse((x+4*s,y-92*s,x+24*s,y-30*s), fill=body, outline=(160,160,160))
    draw.ellipse((x-9*s,y-8*s,x-4*s,y-3*s), fill=(30,30,30))
    draw.ellipse((x+4*s,y-8*s,x+9*s,y-3*s), fill=(30,30,30))
    draw.ellipse((x-4*s,y+2*s,x+4*s,y+8*s), fill=(240,140,155))

def draw_fish(draw, x, y, s=1.0):
    draw.ellipse((x-48*s,y-25*s,x+35*s,y+25*s), fill=(55,165,235), outline=(25,110,180), width=3)
    draw.polygon([(x-50*s,y),(x-80*s,y-28*s),(x-80*s,y+28*s)], fill=(45,140,215))
    draw.ellipse((x+16*s,y-7*s,x+23*s,y), fill=(20,20,20))
    draw.arc((x+15*s,y,x+31*s,y+14*s), 10,170, fill=(20,80,120), width=2)

def draw_rainbow(draw, cx, cy, base_r=180):
    cols=[(235,60,80),(255,145,40),(255,215,70),(70,185,95),(70,150,240),(150,95,215)]
    width=16
    for i,c in enumerate(cols):
        r=base_r-i*width
        draw.arc((cx-r,cy-r,cx+r,cy+r), 180,360, fill=c, width=width)

def text_center(draw, txt, y, font, fill=(35,35,55)):
    # anchor="mm" works with RAQM and Arabic
    draw.text((W/2,y), txt, font=font, fill=fill, anchor="mm", direction="rtl")

def build_frame(t):
    # scene selection
    for s0,s1,bg,lines,kind in scenes:
        if s0 <= t < s1:
            local=(t-s0)/(s1-s0)
            break
    im=Image.new("RGB",(W,H),bg)
    d=ImageDraw.Draw(im)

    # sky decoration
    draw_cloud(d, 60 + 20*math.sin(t*0.4), 55, 0.7)
    draw_cloud(d, 760 + 15*math.sin(t*0.3+1), 85, 0.6)

    # moving ground / waves
    if kind in ("blue",):
        d.rectangle((0,360,W,H), fill=(92,190,235))
        for i in range(7):
            x=i*170 + (t*20)%170 - 170
            d.arc((x,330,x+150,395),0,180,fill=(230,250,255),width=5)
    else:
        d.rectangle((0,430,W,H), fill=(115,205,105))

    # scene characters
    bob = 8*math.sin(t*2*math.pi/2.0)
    if kind=="red":
        for k,x in enumerate([170,320,680,810]):
            draw_apple(d, x, 390 + 8*math.sin(t*2+k), 0.8)
        draw_sun(d, 835, 105, 42)
    elif kind=="yellow":
        draw_sun(d, 820, 110, 52)
        bx=160 + ((t-10)*70)%650
        by=250 + 35*math.sin((t-10)*2.6)
        draw_bee(d,bx,by,1.0)
        for x in range(120,900,120):
            d.ellipse((x,395,x+35,430), fill=(255,120,155))
            d.rectangle((x+15,425,x+20,460), fill=(70,160,75))
    elif kind=="green":
        draw_tree(d, 160, 320, 1.0)
        draw_tree(d, 800, 330, 0.85)
        bx=250 + ((t-20)*85)%500
        draw_bunny(d,bx,410 + 10*math.sin((t-20)*5),0.9)
    elif kind=="blue":
        for k in range(3):
            fx=180 + k*270 + 35*math.sin(t*0.7+k)
            fy=390 + 45*math.sin(t*1.5+k)
            draw_fish(d,fx,fy,0.8)
    elif kind=="mix":
        draw_apple(d,180,395+bob,0.7)
        draw_sun(d,790,115,38)
        draw_tree(d,800,350,0.65)
        draw_fish(d,260,400-bob,0.55)
        draw_bunny(d,690,415+bob,0.6)
    elif kind=="rainbow":
        draw_rainbow(d,W//2,440,190)
        draw_sun(d,820,105,40)
        draw_bunny(d,180,420+bob,0.65)
        draw_fish(d,780,410-bob,0.55)

    # lyric card
    card_y1, card_y2 = 120, 325
    rounded_rect(d, (130,card_y1,830,card_y2), 28, (255,255,255), outline=(220,220,235), width=3)

    # 4 lines across 10s -> 2.5s each
    line_idx = min(3, int(local*4))
    for i,line in enumerate(lines):
        y=160+i*45
        col=(55,55,75) if i!=line_idx else (210,65,85)
        f=font_lyric if i==line_idx else font_small
        text_center(d,line,y,f,col)

    # title banner first 2.5 sec
    if t < 2.5:
        alpha_phase = min(1,t/0.5, (2.5-t)/0.5)
        banner=Image.new("RGBA",(W,H),(0,0,0,0))
        bd=ImageDraw.Draw(banner)
        bd.rounded_rectangle((170,20,790,100), radius=28, fill=(255,255,255,int(235*alpha_phase)))
        bd.text((W/2,60),"أغنية الألوان المرحة",font=font_title,fill=(65,75,155,int(255*alpha_phase)),anchor="mm",direction="rtl")
        im=Image.alpha_composite(im.convert("RGBA"),banner).convert("RGB")

    # progress dots
    dd=ImageDraw.Draw(im)
    for i in range(6):
        x=405+i*30
        c=(90,90,120) if i <= int(t//10) else (190,190,205)
        dd.ellipse((x,500,x+12,512), fill=c)
    return im

# Encode raw frames directly to ffmpeg
ffmpeg = shutil.which("ffmpeg")
cmd = [
    ffmpeg, "-y",
    "-f","rawvideo","-vcodec","rawvideo","-pix_fmt","rgb24",
    "-s",f"{W}x{H}","-r",str(fps),"-i","-",
    "-i",wav_path,
    "-c:v","libx264","-preset","medium","-crf","23","-pix_fmt","yuv420p",
    "-c:a","aac","-b:a","160k",
    "-t","60","-movflags","+faststart",
    mp4_path
]
proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
try:
    total_frames = int(duration*fps)
    for f in range(total_frames):
        t = f/fps
        frame = np.asarray(build_frame(t), dtype=np.uint8)
        proc.stdin.write(frame.tobytes())
    proc.stdin.close()
    stderr = proc.stderr.read().decode("utf-8", errors="ignore")
    rc = proc.wait()
    if rc != 0:
        raise RuntimeError(stderr[-3000:])
finally:
    try:
        proc.stdin.close()
    except Exception:
        pass

# Basic verification
probe = subprocess.run([
    ffmpeg.replace("ffmpeg","ffprobe"),
    "-v","error","-show_entries","format=duration,size",
    "-of","default=noprint_wrappers=1", mp4_path
], capture_output=True, text=True)

print("Created:", mp4_path)
print(probe.stdout.strip())