الوسائط: الصور والفيديو والبث الأدلة التقنية

البث المتكيف Adaptive Streaming: صيغتا HLS أو DASH والتحويل

كيف تصمم سلم الجودات والأجزاء للبث المتكيف، وماذا يقرر hls.js وdash.js عندما تنخفض السرعة، ولماذا توقف الفيديو بسبب رقم واحد في القائمة.

البث المتكيف Adaptive Streaming: صيغتا HLS أو DASH والتحويل

لنفرض أن لديك شركة ناشئة تدير منصة دورات تعليمية مسجلة، وهي نفس المنصة التي بنينا لها أوامر القص والترجمة والشعار في FFmpeg عملياً، وكانت تعرض كل محاضرة كملف MP4 واحد بدقة 1080p ومعدل 5 ميجابت في الثانية، وكل شيء يعمل بشكل ممتاز على شبكة المكتب. ثم بدأت التقييمات السيئة تصل من الطلاب: الفيديو يتوقف كل دقيقة على بيانات الهاتف، ومن يفتح المحاضرة في السيارة يرى دائرة التحميل أكثر مما يرى المدرب، ومن لديه اتصال ممتاز يشكو من أن القفز إلى منتصف المحاضرة يأخذ ثوان طويلة. والسبب في كل هذه الشكاوى واحد: ملف واحد بمعدل واحد لا يناسب كل الاتصالات، فالهاتف الذي يحصل على 2 ميجابت لا يستطيع أن يشغل ملفاً يحتاج 5 ميجابت، ولا يوجد شيء يستطيع المشغل أن يفعله غير الانتظار.

والحل الذي تستخدمه كل منصات الفيديو الكبيرة اسمه البث المتكيف بحسب معدل البت Adaptive Bitrate Streaming، واختصاراً ABR: تصنع من كل فيديو عدة نسخ بجودات مختلفة، وتقطع كل نسخة إلى أجزاء قصيرة، وتكتب قائمة بها، ثم يختار المشغل في كل لحظة الجودة التي يتحملها الاتصال الآن، وينتقل بينها دون أن يتوقف الفيديو. وقد شرحنا الفكرة العامة وبروتوكولات HLS وDASH من جهة المفاهيم في كيف يعمل بث الفيديو، وبنينا خطاً كاملاً لمنصة عند الطلب في منصة فيديو مثل Netflix، أما هنا فسوف ندخل في التفاصيل العملية التي تظهر فقط عندما تشغل هذا بنفسك وتقيسه.

وفي هذا المقال سوف نتناول:

  • لماذا يفشل الملف الواحد حتى مع التحميل التدريجي، بالأرقام.
  • القطع الأربع للبث المتكيف: سلم الجودات، والأجزاء، والقوائم، والمشغل، وكيف تتصل ببعضها.
  • تصميم سلم الجودات Bitrate Ladder: عدد الدرجات والمسافة بينها، ولماذا نحدد سقف المعدل، وأي دقة تفوز عند كل معدل بقياس حقيقي.
  • CMAF: مجموعة واحدة من الأجزاء تخدم HLS وDASH معاً، وقراءة القائمتين سطراً سطراً.
  • ما الذي يحدث داخل hls.js وdash.js عندما يقرران الجودة، وإعداداتهما الافتراضية.
  • تجربة عملية: نخفض سرعة الشبكة أثناء التشغيل ونراقب المشغلين، ونجد خطأ في القائمة التي يكتبها FFmpeg نفسه، ونقارن الأجزاء القصيرة بالطويلة.
  • أتمتة التحويل: مجلد يراقبه سكربت ويحول كل فيديو جديد إلى حزمة جاهزة للبث.
  • التوصيل والتكلفة والمقاييس التي تراقبها بعد الإطلاق.

لماذا لا يكفي ملف MP4 واحد؟

الطريقة البسيطة لعرض الفيديو على الويب هي أن تضع ملف MP4 على السيرفر وتكتب له وسم <video>، ويقوم المتصفح بتحميله تدريجياً Progressive Download ويبدأ التشغيل قبل أن يكتمل التحميل، ويطلب أجزاء من الملف عند القفز بطلبات المدى Range Requests. وهذه الطريقة تعمل بشكل ممتاز ما دامت سرعة الاتصال أكبر من معدل بت الملف، ولكن عندما تكون السرعة أقل منه فالحساب بسيط وقاس: محاضرة مدتها عشر دقائق بمعدل 5 ميجابت في الثانية حجمها قرابة 375 ميجابايت، وعلى اتصال سرعته 2 ميجابت في الثانية يحتاج تحميل كل ثانية من الفيديو 2.5 ثانية، وبالتالي إذا أراد المشغل أن يعرض المحاضرة كاملة دون توقف فعليه أن ينتظر قبل البدء 600 × (1 − 2/5) = 360 ثانية، أي ست دقائق كاملة من الانتظار، وإذا بدأ مبكراً فسوف يتوقف مرة بعد مرة حتى يجمع نفس الست دقائق على دفعات. ولا يوجد إعداد في المشغل يحل هذا، لأن المشكلة ليست في المشغل وإنما في أن الملف أثقل من الاتصال.

وقد يتساءل البعض: لماذا لا نرفع ملفاً ثانياً بدقة 480p ونترك الطالب يختار؟ والإجابة أن هذا هو الحل الثاني الذي تجربه كل منصة، وهو أفضل من الملف الواحد ولكنه يفشل لسببين: الأول أن الطالب لا يعرف سرعة اتصاله، ولا يعرف أنها سوف تنخفض بعد دقيقتين عندما يدخل المصعد، والثاني أن الانتقال بين الملفين يعني أن يبدأ المشغل ملفاً جديداً من الموضع الحالي، فيتوقف الفيديو ويفقد ما حمله مسبقاً. والحل الصحيح أن يكون القرار آلياً ومستمراً، وأن يكون الانتقال بين الجودات ممكناً كل ثانيتين دون توقف، وهذا بالضبط ما يقدمه البث المتكيف.

القطع الأربع للبث المتكيف Adaptive Streaming

البث المتكيف ليس بروتوكولاً خاصاً على السيرفر، فالسيرفر في الحقيقة يقدم ملفات ثابتة عبر HTTP مثل أي صور أو ملفات JavaScript، وكل الذكاء موجود في طريقة تحضير الملفات وفي المشغل. وهناك أربع قطع يجب أن تفهمها، لأن كل مشكلة سوف تراها في هذا المقال سببها قطعة منها:

  1. سلم الجودات Bitrate Ladder: عدة نسخ Renditions من نفس الفيديو، كل نسخة بدقة ومعدل بت مختلفين، مثل 1080p بمعدل 5000 كيلوبت و360p بمعدل 700 كيلوبت.
  2. الأجزاء Segments: كل نسخة مقطعة إلى أجزاء قصيرة متساوية، ثانيتين أو ست ثوان، وكل جزء يبدأ بإطار مفتاحي Keyframe في نفس اللحظة في كل النسخ، وبالتالي يستطيع المشغل أن يأخذ الجزء رقم 7 من 1080p ثم الجزء رقم 8 من 480p وتستمر الصورة دون انقطاع.
  3. القوائم Manifests: ملف نصي يصف النسخ ومعدل كل منها ومكان أجزائها، وهو master.m3u8 في HLS وmanifest.mpd في DASH.
  4. المشغل Player: كود JavaScript في الصفحة، مثل hls.js وdash.js وShaka Player، أو مشغل النظام نفسه في أجهزة Apple، يقرأ القائمة ويقيس سرعة التحميل ومخزن الفيديو المؤقت Buffer، ويقرر قبل كل جزء أي نسخة يطلب، ثم يضع البيانات في عنصر الفيديو عبر واجهة امتدادات مصدر الوسائط Media Source Extensions، واختصاراً MSE.

والصورة التالية تبين كيف تتصل القطع الأربع: سلم الجودات والأجزاء يصنعان مرة واحدة عند رفع الفيديو، والقوائم تصف ما صنع، والمشغل هو الوحيد الذي يعمل أثناء المشاهدة.

رسم توضيحي للبث المتكيف: على اليمين ملف المحاضرة الأصلي يدخل إلى سيرفر التحويل الذي يشغل FFmpeg، ويخرج منه أربعة صفوف من الأجزاء لكل جودة 1080p و720p و480p و360p، كل جزء مدته ثانيتان، وفوقها ملفا القائمتين master.m3u8 وmanifest.mpd. ثم CDN أو سيرفر ملفات ثابتة، وعلى اليسار هاتف ومتصفح، وسهم يبين أن المشغل يطلب الجزء 7 من 1080p ثم الجزء 8 من 480p عندما انخفضت السرعة
السيرفر يقدم ملفات ثابتة فقط، والقرار كله عند المشغل في كل جزء

ولاحظ أن هذا التصميم هو سبب انتشار البث المتكيف، فالأجزاء ملفات عادية تخزنها في أي تخزين كائنات Object Storage وتوزعها عبر أي CDN دون برنامج خاص، وهذا ما ميز HLS وDASH عن البروتوكولات القديمة مثل RTMP التي كانت تحتاج سيرفر وسائط يحفظ حالة كل مشاهد. ولكن هذا التصميم يعني أيضاً أن السيرفر لا يعرف شيئاً عن المشاهد ولا يستطيع أن ينقذه، فإذا كانت القائمة تقول عن نسخة إن معدلها 4 ميجابت وهي في الحقيقة تصل إلى 6.7 ميجابت في بعض الأجزاء، فسوف يصدق المشغل القائمة ويتوقف الفيديو، كما سوف نرى في التجربة بالأرقام.

تصميم سلم الجودات Bitrate Ladder

سلم الجودات هو أهم قرار في البث المتكيف، لأنه يحدد ما يستطيع المشغل أن يختار منه أصلاً، فالمشغل الذكي لا يستطيع أن يعرض 720p لطالب سرعته 2 ميجابت إذا لم يكن في السلم درجة 720p بمعدل يناسب 2 ميجابت. وقد ذكرنا في كيف يعمل بث الفيديو مثال Apple كنقطة بداية، أما هنا فالأسئلة العملية: كم درجة، وما المسافة بينها، وأي دقة لكل معدل، وكيف تحدد سقف المعدل.

كم درجة Rung في السلم، وما المسافة بينها؟

القاعدة المعروفة أن تكون كل درجة قرابة 1.5 إلى ضعفي الدرجة التي تحتها، والسبب أن المسافة الكبيرة بين درجتين تعني أن المشغل الذي لا يتحمل اتصاله الدرجة العليا ينزل إلى درجة أقل بكثير مما يتحمله، فطالب سرعته 2.5 ميجابت في سلم فيه 5000 و700 فقط سوف يشاهد 700 طوال الوقت، بينما المسافة الصغيرة جداً تعني درجات كثيرة متقاربة في الجودة، وكل درجة تكلفك وقت تحويل وتخزيناً، وتجعل المشغل يتنقل كثيراً بين جودات لا يرى المشاهد الفرق بينها. وفي سلمنا في التجربة أربع درجات: 5000 و2800 و1200 و700 كيلوبت، أي نسب 1.8 و2.3 و1.7 تقريباً، وسوف نرى أن الدرجة الدنيا مهمة بقدر الدرجة العليا، لأن المشاهد الذي يقل اتصاله عن أدنى درجة سوف يتوقف الفيديو عنده مهما كان المشغل ذكياً.

لماذا نحدد سقف المعدل Capped VBR؟

في مفاهيم الفيديو للمبتدئين ذكرنا أن الجودة الثابتة CRF تعطي أفضل جودة لكل بايت، لأنها تعطي المشهد الصعب بتات أكثر والمشهد السهل بتات أقل، ولكن هذه الميزة نفسها هي المشكلة في البث المتكيف، فالمشغل يختار النسخة بحسب معدلها المعلن، وإذا كان المعلن 2800 كيلوبت والمشهد الحالي يحتاج 9000 فسوف يتأخر الجزء ويفرغ المخزن. لذلك نستخدم في البث المتكيف معدلاً متغيراً بسقف Capped VBR، وفي libx264 يتكون من ثلاثة خيارات:

  • -b:v 2800k: المعدل المستهدف في المتوسط.
  • -maxrate 3000k: الحد الأعلى الذي لا يتجاوزه المعدل على مدى المخزن.
  • -bufsize 5600k: حجم المخزن الافتراضي VBV Buffer الذي يقاس عليه الحد، وكلما كبر سمح بتذبذب أكبر في المعدل لحظياً.

ويجدر الإشارة هنا إلى أن السقف لا يعني أن كل جزء مدته ثانيتان لن يتجاوز 3000 كيلوبت، فالمخزن الافتراضي حجمه ثانيتان تقريباً من المعدل الأعلى، والجزء الذي يحتوي إطاراً مفتاحياً كبيراً في بدايته قد يتجاوز السقف، وقد قسنا ذلك في التجربة فوجدنا أن أعلى جزء في نسخة 720p وصل إلى 3960 كيلوبت مع أن السقف 3000. وهذا هو السبب في أن معيار HLS يطلب أن يكون المعدل المعلن هو أعلى معدل للأجزاء وليس المتوسط، كما سيأتي.

الإطارات المفتاحية Keyframes: نفس اللحظة في كل الدرجات

حتى يستطيع المشغل أن ينتقل من درجة إلى أخرى عند حدود الجزء، يجب أن يبدأ كل جزء في كل الدرجات بإطار مفتاحي في نفس اللحظة، وإلا فإن الجزء الجديد يحتاج إطارات من جزء لم يحمله المشغل. والطريقة المضمونة في FFmpeg أن تجعل الفاصل بين الإطارات المفتاحية ثابتاً ومساوياً لمدة الجزء أو قاسماً لها، وأن تمنع المرمز من إضافة إطارات مفتاحية عند تغير المشهد:

  • -g 48 -keyint_min 48: إطار مفتاحي كل 48 إطاراً بالضبط، أي كل ثانيتين في فيديو 24 إطاراً في الثانية.
  • -sc_threshold 0: يمنع libx264 من وضع إطار مفتاحي عند تغير المشهد Scene Cut، لأن هذا الإطار يقع في مكان مختلف في كل درجة، فالدرجات لا ترى نفس التفاصيل.

وقد جربنا في كيف يعمل بث الفيديو ما يحدث عندما تكون الإطارات المفتاحية في أماكن عشوائية، فلن نكرره هنا، ولكن تذكر أن خطأ -g لا يظهر في التشغيل العادي، ويظهر فقط عندما ينتقل المشغل بين الدرجات، أي عند الطالب الذي اتصاله ضعيف بالضبط.

أي دقة Resolution لكل معدل Bitrate؟

السؤال الذي يغفل عنه الكثير: إذا كان لديك 1200 كيلوبت فقط، فهل الأفضل أن تصرفها على 1080p أم 720p أم 480p؟ والجواب البديهي أن الدقة الأعلى أفضل دائماً، ولكنه غير صحيح، فعند معدل منخفض لا يكفي البت لتفاصيل 1080p فيضطر المرمز إلى ضغطها بشدة فتظهر الكتل Blocking والتمويه، بينما 480p بنفس المعدل تعطي كل بكسل بتات أكثر، وعندما يكبرها المشغل إلى الشاشة تكون أنظف. وفي المقابل عند معدل عال تكون الدقة المنخفضة محدودة بعدد بكسلاتها مهما أعطيتها من البتات. ولهذا فلكل معدل دقة تفوز، ومجموع النقاط الفائزة يسمى الغلاف المحدب Convex Hull، وهو الفكرة التي بنت عليها Netflix ما سمته ترميز كل فيديو بسلمه Per-Title Encoding سنة 2015، وشرحناها في منصة فيديو مثل Netflix. وفي التجربة سوف نقيس هذا على مقطعنا بأربع دقات وأربعة معدلات، لترى أين تقع نقاط التحول فعلاً.

صيغة CMAF: أجزاء واحدة لبروتوكولي HLS مع DASH

في البداية كان HLS من Apple يستخدم أجزاء بصيغة MPEG-TS، وكان DASH من MPEG يستخدم أجزاء MP4 مجزأة Fragmented MP4، فكانت المنصة التي تريد أن تخدم أجهزة Apple والمتصفحات وأجهزة التلفاز تخزن كل فيديو مرتين وتدفع ثمن التخزين مرتين، والأسوأ أن ال CDN يخزن نسختين فتقل نسبة الطلبات التي يجدها في ذاكرته Cache Hit Ratio. ثم اتفقت Apple وMicrosoft على صيغة مشتركة صارت معياراً سنة 2018 باسم صيغة تطبيقات الوسائط المشتركة Common Media Application Format، واختصاراً CMAF، وهي في الحقيقة MP4 مجزأ بقيود محددة، وأصبح HLS يقبلها منذ 2016. والنتيجة أنك تصنع مجموعة واحدة من الأجزاء، ثم تكتب لها قائمتين: قائمة HLS وقائمة DASH، وهذا ما فعلناه في التجربة بأمر FFmpeg واحد.

وكل نسخة في CMAF تتكون من ملف تهيئة Initialization Segment صغير يحمل وصف الترميز، ثم أجزاء الوسائط Media Segments. وقمنا بقراءة الصناديق Boxes داخل ملفين من نسخة 720p في التجربة، والمخرج سوف يكون كما يلي:

init-stream1.m4s ftyp(28) moov(826)   mvhd(108)   trak(572)   mvex(40)   udta(98)
chunk-stream1-00007.m4s styp(24) sidx(52) moof(680)   mfhd(16)   traf(656) mdat(591169)

في المخرج أعلاه لاحظ التالي:

  • ملف التهيئة 854 بايت فقط، وفيه الصندوق moov الذي يصف الترميز والدقة، والصندوق mvex الذي يخبر المشغل أن البيانات سوف تأتي في أجزاء منفصلة. ويحمله المشغل مرة واحدة لكل نسخة.
  • كل جزء فيه moof يصف الإطارات وأوقاتها في 680 بايت، ثم mdat الذي يحمل الإطارات نفسها في قرابة 591 كيلوبايت، أي أن الوصف أقل من 0.2% من حجم الجزء.
  • عندما ينتقل المشغل إلى نسخة أخرى يحمل ملف التهيئة الخاص بها أولاً، ثم يكمل بأجزائها، ولهذا يسمح المعيار بأن تختلف الدقة بين النسخ.

قراءة قائمة HLS الرئيسية Master Playlist

قائمة HLS الرئيسية Master Playlist هي أول ملف يطلبه المشغل، وهذه القائمة كما كتبها FFmpeg في التجربة قبل أن نعدلها:

#EXTM3U
#EXT-X-VERSION:7
#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_A1",NAME="audio_4",DEFAULT=YES,CHANNELS="2",URI="media_4.m3u8"
#EXT-X-STREAM-INF:BANDWIDTH=4073321,RESOLUTION=1920x1080,CODECS="avc1.640028,mp4a.40.2",AUDIO="group_A1"
media_0.m3u8

#EXT-X-STREAM-INF:BANDWIDTH=1869127,RESOLUTION=1280x720,CODECS="avc1.64001f,mp4a.40.2",AUDIO="group_A1"
media_1.m3u8

#EXT-X-STREAM-INF:BANDWIDTH=711848,RESOLUTION=854x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_A1"
media_2.m3u8

#EXT-X-STREAM-INF:BANDWIDTH=412999,RESOLUTION=640x360,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_A1"
media_3.m3u8

في القائمة أعلاه لاحظ التالي:

  • EXT-X-MEDIA يعرف مسار الصوت مرة واحدة كمجموعة group_A1، وكل نسخة فيديو تشير إليه، فالصوت لا يتكرر داخل كل نسخة فيديو ولا يتغير عند تغيير الجودة.
  • BANDWIDTH هو الرقم الذي يبني عليه المشغل قراره، وRESOLUTION يستخدمه المشغل ليتجنب نسخة أكبر من حجم المشغل على الشاشة إذا طلبت منه ذلك.
  • CODECS يخبر المتصفح قبل أن يحمل أي جزء هل يستطيع فك هذا الترميز، فالقيمة avc1.640028 تعني H.264 بملف High Profile والمستوى 4.0، وmp4a.40.2 تعني AAC-LC.
  • والأهم: قيمة BANDWIDTH لنسخة 1080p هي 4,073,321 بت، مع أننا رمزناها بمعدل 5000 كيلوبت، ولنسخة 720p هي 1,869,127 مع أنها 2800. وهذا ليس خطأ في الترميز، وسوف نعود إليه في التجربة لأنه أخطر سطر في المقال.

ثم لكل نسخة قائمة وسائط Media Playlist تسرد أجزاءها، وهذا أولها لنسخة 1080p:

#EXTM3U
#EXT-X-VERSION:6
#EXT-X-TARGETDURATION:2
#EXT-X-MEDIA-SEQUENCE:1
#EXT-X-MAP:URI="init-stream0.m4s"
#EXTINF:1.999000,
#EXT-X-PROGRAM-DATE-TIME:2026-10-28T15:16:37.000+0000
chunk-stream0-00001.m4s
#EXTINF:2.000000,

وEXT-X-MAP هو ملف التهيئة، وEXTINF مدة كل جزء، وEXT-X-TARGETDURATION أطول مدة لأي جزء مقربة لأعلى، ومنها يعرف المشغل كم ثانية يحمل كل طلب. أما EXT-X-PROGRAM-DATE-TIME فيكتبه FFmpeg بوقت التحويل نفسه، وهو مفيد في البث المباشر لربط الجزء بوقت حقيقي، ولا قيمة له في فيديو مسجل، ولا يضر.

قراءة ملف DASH الوصفي MPD

قائمة DASH ملف XML اسمه وصف العرض الإعلامي Media Presentation Description، واختصاراً MPD، وفيه نفس المعلومات بترتيب مختلف: مجموعة تكيف Adaptation Set للفيديو وأخرى للصوت، وداخل كل منها تمثيلات Representations هي النسخ:

<MPD ... profiles="urn:mpeg:dash:profile:isoff-live:2011" type="static"
     mediaPresentationDuration="PT2M0.0S" maxSegmentDuration="PT2.0S" minBufferTime="PT4.0S">
 <Period id="0" start="PT0.0S">
  <AdaptationSet id="0" contentType="video" startWithSAP="1" segmentAlignment="true" bitstreamSwitching="true"
                 frameRate="24/1" maxWidth="1920" maxHeight="1080" par="16:9">
   <Representation id="0" mimeType="video/mp4" codecs="avc1.640028" bandwidth="4904924" width="1920" height="1080" sar="1:1">
    <SegmentTemplate timescale="1000000" duration="2000000" initialization="init-stream$RepresentationID$.m4s"
                     media="chunk-stream$RepresentationID$-$Number%05d$.m4s" startNumber="1">
    </SegmentTemplate>
   </Representation>
   ...
  <AdaptationSet id="1" contentType="audio" ...>
   <Representation id="4" mimeType="audio/mp4" codecs="mp4a.40.2" bandwidth="133847" audioSamplingRate="48000">

في القائمة أعلاه لاحظ التالي:

  • SegmentTemplate لا يسرد الأجزاء واحداً واحداً كما في HLS، وإنما يعطي قالباً للاسم $Number%05d$ ومدة كل جزء، فيحسب المشغل اسم الجزء رقم 37 بنفسه، ولهذا يبقى ملف MPD صغيراً مهما طال الفيديو.
  • segmentAlignment="true" وstartWithSAP="1" وعد من القائمة بأن الأجزاء متحاذية في كل النسخ وتبدأ بإطار مفتاحي، وهو الوعد الذي تحققه الخيارات -g و-sc_threshold 0.
  • bandwidth هنا 4,904,924 لنسخة 1080p، أي المتوسط الفعلي للنسخة كلها، بينما قائمة HLS من نفس الأمر كتبت 4,073,321. نفس الأجزاء ونفس الأمر ورقمان مختلفان، وسوف نرى السبب.
  • minBufferTime="PT4.0S" يقول للمشغل إن مخزناً من أربع ثوان يكفي لتشغيل النسخة بمعدلها المعلن دون توقف.

مدة الجزء Segment Duration: ثانيتان أم ست ثوان؟

كانت Apple توصي قديماً بأجزاء مدتها عشر ثوان، ثم خفضتها إلى ست ثوان في مواصفات التأليف لأجهزة Apple، وأغلب منصات البث اليوم بين ثانيتين وست ثوان. والاختيار بينها تبادل حقيقي:

العاملأجزاء قصيرة (2 ثانية)أجزاء طويلة (6 ثوان)
سرعة رد الفعل عند تغير الاتصالقرار كل ثانيتينقرار كل ست ثوان، والجزء البطيء يحجز المشغل مدة أطول
زمن البدء والقفزجزء صغير يكفي للبدءيجب تحميل جزء كامل أكبر قبل أول صورة
عدد الطلبات والملفاتثلاثة أضعافأقل، وأخف على السيرفر وال CDN
كفاءة الضغطإطار مفتاحي كل ثانيتين على الأقليمكن أن يكون الفاصل أطول، فيقل الحجم قليلاً
دقة قياس السرعةالطلبات الصغيرة يؤثر فيها زمن الوصول Latency أكثرطلبات أكبر تعطي قياساً أدق

ولاحظ أن مدة الجزء لا تحدد الفاصل بين الإطارات المفتاحية بالضرورة، ففي التجربة أبقينا إطاراً مفتاحياً كل ثانيتين في الحالتين، وغيرنا مدة الجزء فقط عند التجزئة، حتى تكون المقارنة على نفس الترميز بالضبط. ولكن العكس غير ممكن، فلا يمكن أن يكون الجزء أقصر من الفاصل بين الإطارات المفتاحية، لأن كل جزء يجب أن يبدأ بإطار مفتاحي.

ماذا يحدث داخل المشغل Player؟

في كيف يعمل بث الفيديو ذكرنا أن طرق القرار ثلاث: بحسب السرعة، وبحسب المخزن، والمختلطة. وهنا سوف ندخل في مشغلين حقيقيين مفتوحي المصدر، لأن الفرق بينهما سوف يظهر بوضوح في التجربة، ولأن أغلب المنصات تستخدم أحدهما أو تبني عليه. والأرقام التالية هي القيم الافتراضية كما قرأناها من الإصدارين اللذين استخدمناهما، hls.js 1.7.3 وdash.js 5.2.1.

hls.js: متوسطان للسرعة وهامش أمان

مشغل hls.js يعتمد أساساً على تقدير السرعة، فبعد كل جزء يحسب سرعة التحميل، ثم يحدث متوسطين متحركين أسيين Exponentially Weighted Moving Average، واختصاراً EWMA: متوسط سريع نصف عمره 3 ثوان من التحميل (abrEwmaFastVoD)، ومتوسط بطيء نصف عمره 9 ثوان (abrEwmaSlowVoD)، ويأخذ الأقل منهما. والسبب في هذا التصميم أن الأقل يجعل المشغل ينزل بسرعة عندما تنخفض السرعة لأن المتوسط السريع يتأثر أولاً، ويصعد ببطء عندما ترتفع لأن المتوسط البطيء يتأخر، وهذا بالضبط ما تريده، فالتوقف أسوأ بكثير من جودة أقل لبضع ثوان. ثم يضرب التقدير في هامش أمان: 0.95 عند البقاء أو النزول (abrBandWidthFactor)، و0.7 فقط عند الصعود (abrBandWidthUpFactor)، أي أن المشغل لا يصعد إلى نسخة إلا إذا كانت سرعته المقدرة أعلى من معدلها المعلن بقرابة 43%.

وفي البداية لا توجد قياسات، فيبدأ بتقدير افتراضي 500 كيلوبت (abrEwmaDefaultEstimate)، ويحمل مخزناً حتى 30 ثانية (maxBufferLength)، وإذا لاحظ أثناء تحميل جزء أن الجزء لن يكتمل قبل أن يفرغ المخزن، فإنه يلغي الطلب ويطلب نفس الجزء من نسخة أقل، وهذا ما يسمى قاعدة التخلي Abandon Rule. ولاحظ أن كل هذه الحسابات تقارن السرعة المقاسة بقيمة BANDWIDTH في القائمة، فإذا كانت القيمة خاطئة كان القرار خاطئاً مهما كانت الحسابات دقيقة.

dash.js: قواعد تختار معاً ABR Rules

أما dash.js، المشغل المرجعي من منتدى DASH الصناعي DASH-IF، فيستخدم مجموعة قواعد Rules، كل قاعدة تقترح جودة، ثم يجمع اقتراحاتها، والقواعد المفعلة افتراضياً في الإصدار الذي استخدمناه:

  • قاعدة السرعة ThroughputRule: مثل hls.js، متوسطان أسيان بنصف عمر 3 و8 ثوان، وهامش أمان 0.9 (bandwidthSafetyFactor).
  • قاعدة BOLA: خوارزمية تختار الجودة من مستوى المخزن وحده دون قياس السرعة، ونشرها الباحثون Kevin Spiteri وRahul Urgaonkar وRamesh Sitaraman سنة 2016 في ورقة BOLA، وفكرتها أن المخزن الممتلئ يعني أن الاتصال يتحمل أكثر، والمخزن الذي يفرغ يعني العكس، فلا تتأثر بقياس سرعة خاطئ.
  • قاعدة نقص المخزن InsufficientBufferRule: إذا قارب المخزن الفراغ تفرض نسخة يتحملها 70% من السرعة المقاسة.
  • قاعدة التخلي AbandonRequestsRule: تلغي الطلب الذي سوف يأخذ أكثر من 1.8 ضعف مدة الجزء.
  • قاعدة سجل التبديل SwitchHistoryRule: إذا تكرر النزول من نسخة كثيراً تمنع الصعود إليها لفترة، حتى لا يتأرجح المشغل.

والنتيجة استراتيجية مختلطة يسميها dash.js الديناميكية Dynamic: في البداية والمخزن فارغ يعتمد على السرعة، وعندما يصل المخزن إلى 12 ثانية (hybridSwitchBufferTime) ينتقل إلى BOLA، ويحمل مخزناً حتى 30 ثانية عند أعلى جودة (bufferTimeAtTopQuality). والصورة التالية تلخص الحلقة التي يدور فيها المشغلان قبل كل جزء.

رسم لحلقة القرار في المشغل قبل كل جزء: يقيس سرعة تحميل الجزء السابق ويحدث متوسطين أسيين سريع وبطيء ويأخذ الأقل، ويقرأ مستوى المخزن المؤقت بالثواني، ثم يقارن بمعدل كل نسخة المعلن في القائمة مع هامش أمان، فيختار النسخة ويطلب الجزء التالي، وأثناء التحميل تراقب قاعدة التخلي هل سوف يفرغ المخزن قبل اكتمال الجزء فتلغيه وتطلب نسخة أقل. وبجانبه مقارنة قصيرة: hls.js يعتمد على السرعة بهامش 0.95 للنزول و0.7 للصعود ومخزن حتى 30 ثانية، وdash.js يجمع السرعة وBOLA ونقص المخزن والتخلي
القرار يتكرر قبل كل جزء، ويبنى على رقمين: السرعة المقاسة، والمعدل المعلن في القائمة

تجربة عملية Lab: سلم كامل ومشغلان وشبكة نتحكم في سرعتها

في هذه التجربة سوف نبني الحزمة بأنفسنا، ثم نشغلها في متصفح Chrome دون واجهة Headless مرة مع hls.js ومرة مع dash.js، ونتحكم في سرعة الشبكة أثناء التشغيل عبر بروتوكول أدوات المطور Chrome DevTools Protocol، ونسجل ما يقرره كل مشغل وما يحمله وكم مرة يتوقف. واستخدمنا FFmpeg 8.1.2 من حزمة Alpine داخل ال Docker Image bluenviron/mediamtx:1.21.1-ffmpeg، وهو نفس الإصدار الذي استخدمناه في FFmpeg عملياً.

الفيديو المصدر Source Video

استخدمنا فيلم Big Buck Bunny المفتوح من مؤسسة Blender بدقة 1080p، وأخذنا منه دقيقتين بدءاً من الثانية 60 بنسخ الدفق دون إعادة ترميز:

curl -LO https://download.blender.org/peach/bigbuckbunny_movies/big_buck_bunny_1080p_h264.mov.zip
unzip big_buck_bunny_1080p_h264.mov.zip
docker run --rm -v "$PWD:/w" -w /w --entrypoint ffmpeg bluenviron/mediamtx:1.21.1-ffmpeg \
  -hide_banner -v error -ss 60 -i big_buck_bunny_1080p_h264.mov -t 120 -map 0:v:0 -map 0:a:0 -c copy bbb120.mov
docker run --rm -v "$PWD:/w" -w /w --entrypoint ffprobe bluenviron/mediamtx:1.21.1-ffmpeg \
  -v error -show_entries format=duration:stream=codec_name,width,height,r_frame_rate,channels -of compact bbb120.mov

والمخرج سوف يكون كما يلي:

stream|codec_name=h264|width=1920|height=1080|r_frame_rate=24/1
stream|codec_name=aac|channels=6
format|duration=120.041667

لاحظ أن الصوت ست قنوات 5.1، ولهذا سوف نضيف -ac 2 عند الترميز، لأن أغلب المتصفحات والهواتف تعرض الصوت بقناتين، ولا داعي لنقل أربع قنوات إضافية لكل مشاهد. ولاحظ أيضاً أن الفيديو 24 إطاراً في الثانية، وهذا يحدد قيمة -g.

ترميز Encoding السلم مرة واحدة

بدلاً من أن نرمز ونجزئ في أمر واحد، قمنا بفصل الخطوتين: نرمز السلم كله مرة واحدة في ملف وسيط ladder.mkv فيه أربعة دفقات فيديو ودفق صوت، ثم نجزئه بنسخ الدفق بأي مدة أجزاء نريدها. والسبب أن الترميز هو المرحلة المكلفة، والتجزئة بنسخ الدفق تأخذ ثوان، فنستطيع أن نجرب مدداً مختلفة للأجزاء على نفس الترميز بالضبط. وهذا ملف enc.sh الذي استخدمناه:

#!/bin/sh
# Encode the ladder once (ladder.mkv: 4 video renditions + 1 audio), then package it (CMAF segments, DASH + HLS).
#   enc.sh encode
#   enc.sh low                                   extra 416x234 rung at 200 kbps (low.mkv)
#   enc.sh package <seconds> <dir> [declared]    declared = write the measured peak bitrates into the manifests
#   enc.sh packagelow <seconds> <dir>            the ladder plus the 234p rung
T() { /usr/bin/time -f "%e s wall, %U s user, %M KB" "$@"; }
PEAKS="-b:v:0 6750k -b:v:1 3960k -b:v:2 1700k -b:v:3 1000k"
DASH='-f dash -use_template 1 -use_timeline 0 -hls_playlist 1'
cd /w
case "$1" in
encode)
  T ffmpeg -hide_banner -v error -nostdin -y -i bbb120.mov -filter_complex \
   "[0:v]split=4[a][b][c][d];[a]scale=1920:1080[v1];[b]scale=1280:720[v2];[c]scale=854:480[v3];[d]scale=640:360[v4]" \
   -map "[v1]" -map "[v2]" -map "[v3]" -map "[v4]" -map 0:a:0 \
   -c:v libx264 -preset veryfast -profile:v high -pix_fmt yuv420p -g 48 -keyint_min 48 -sc_threshold 0 \
   -b:v:0 5000k -maxrate:v:0 5350k -bufsize:v:0 10000k \
   -b:v:1 2800k -maxrate:v:1 3000k -bufsize:v:1 5600k \
   -b:v:2 1200k -maxrate:v:2 1300k -bufsize:v:2 2400k \
   -b:v:3 700k  -maxrate:v:3 750k  -bufsize:v:3 1400k \
   -c:a aac -b:a 128k -ac 2 ladder.mkv ;;
low)
  T ffmpeg -hide_banner -v error -nostdin -y -i bbb120.mov -an -vf scale=416:234 \
   -c:v libx264 -preset veryfast -profile:v main -pix_fmt yuv420p -g 48 -keyint_min 48 -sc_threshold 0 \
   -b:v 200k -maxrate 215k -bufsize 400k low.mkv ;;
package)
  rm -rf /tmp/p "$3"; mkdir -p /tmp/p
  [ "$4" = declared ] && B="$PEAKS" || B=""
  T ffmpeg -hide_banner -v error -nostdin -y -i ladder.mkv -map 0 -c copy -aspect:v 16:9 $B \
   $DASH -seg_duration "$2" -adaptation_sets "id=0,streams=v id=1,streams=a" /tmp/p/manifest.mpd
  cp -r /tmp/p "$3"; echo "files: $(ls "$3" | wc -l)  bytes: $(du -cb "$3"/* | tail -1 | cut -f1)" ;;
packagelow)
  rm -rf /tmp/p "$3"; mkdir -p /tmp/p
  T ffmpeg -hide_banner -v error -nostdin -y -i ladder.mkv -i low.mkv -map 0:v -map 1:v -map 0:a -c copy -aspect:v 16:9 \
   $PEAKS -b:v:4 300k $DASH -seg_duration "$2" -adaptation_sets "id=0,streams=v id=1,streams=a" /tmp/p/manifest.mpd
  cp -r /tmp/p "$3"; echo "files: $(ls "$3" | wc -l)  bytes: $(du -cb "$3"/* | tail -1 | cut -f1)" ;;
esac

ثم نشغل الترميز:

docker run --rm -v "$PWD:/w" --entrypoint sh bluenviron/mediamtx:1.21.1-ffmpeg /w/enc.sh encode
821.85 s wall, 678.58 s user, 1007132 KB

في الإعداد والمخرج أعلاه لاحظ التالي:

  • المرشح split=4 يفك الفيديو مرة واحدة ويوزع الإطارات على أربعة مرشحات تصغير، بدلاً من أن يفك المصدر أربع مرات في أربعة أوامر.
  • الخيارات بعد -b:v:0 و-b:v:1 تخص كل دفق فيديو برقمه، فكل درجة لها معدلها وسقفها ومخزنها، وهذه صيغة FFmpeg لتحديد خيار لدفق واحد.
  • أخذ ترميز دقيقتين بأربع درجات 678 ثانية من زمن المعالج، أي قرابة 5.7 ثانية معالج لكل ثانية فيديو بإعداد veryfast، ونسخة 1080p وحدها فيها بكسلات أكثر من الدرجات الثلاث الأخرى مجتمعة، فهي صاحبة النصيب الأكبر من هذا الوقت. واستخدم الترميز قرابة 1 جيجابايت من الذاكرة.
  • هذا الرقم هو ما تبني عليه سعة سيرفرات التحويل: عشر ساعات محاضرات في اليوم تعني قرابة 57 ساعة معالج يومياً لهذا السلم، أي سيرفر بست عشرة نواة يعمل قرابة ثلاث ساعات ونصف.

أي دقة Resolution تفوز عند كل معدل؟ القياس على مقطعنا

قبل أن نثق في السلم الذي اخترناه، قمنا بقياس السؤال الذي طرحناه في قسم التصميم: أخذنا 20 ثانية من المقطع، ورمزناها بأربع دقات وأربعة معدلات، ثم كبرنا كل نسخة إلى 1080p كما يفعل المشغل على شاشة كاملة، وقارناها بالأصل بمقياس التشابه البنيوي SSIM، الذي يعطي 1.0 للصورة المطابقة وكلما نقص كان الفرق أوضح للعين. وهذا ملف grid.sh:

#!/bin/sh
# Which resolution looks best at each bitrate? 20 s of the source, 4 sizes x 4 bitrates, SSIM and PSNR measured at 1080p.
cd /w; mkdir -p grid
ffmpeg -hide_banner -v error -nostdin -y -ss 40 -i bbb120.mov -t 20 -an -c:v libx264 -preset veryfast -crf 10 -pix_fmt yuv420p grid/ref.mp4
for r in 1920:1080 1280:720 854:480 640:360; do
  h=${r#*:}
  for kb in 700 1200 2800 5000; do
    f=grid/$h-$kb.mp4
    ffmpeg -hide_banner -v error -nostdin -y -i grid/ref.mp4 -vf scale=$r -c:v libx264 -preset veryfast -b:v ${kb}k -maxrate $((kb*107/100))k -bufsize $((kb*2))k -g 48 -sc_threshold 0 $f
    s=$(ffmpeg -hide_banner -nostdin -i $f -i grid/ref.mp4 -lavfi "[0:v]scale=1920:1080:flags=bicubic[d];[d][1:v]ssim" -f null - 2>&1 | grep -o 'All:[0-9.]*' | cut -d: -f2)
    p=$(ffmpeg -hide_banner -nostdin -i $f -i grid/ref.mp4 -lavfi "[0:v]scale=1920:1080:flags=bicubic[d];[d][1:v]psnr" -f null - 2>&1 | grep -o 'average:[0-9.]*' | cut -d: -f2)
    echo "${h}p ${kb}k ssim=$s psnr=$p bytes=$(stat -c %s $f)"
  done
done

والمخرج سوف يكون كما يلي:

1080p 700k ssim=0.947889 psnr=36.430326 bytes=1745795
1080p 1200k ssim=0.968094 psnr=39.200544 bytes=2950860
1080p 2800k ssim=0.987432 psnr=44.344665 bytes=7054749
1080p 5000k ssim=0.993975 psnr=48.031493 bytes=12696266
720p 700k ssim=0.951025 psnr=36.914252 bytes=1723873
720p 1200k ssim=0.964837 psnr=38.468804 bytes=2990098
720p 2800k ssim=0.975874 psnr=39.844131 bytes=7176228
720p 5000k ssim=0.979212 psnr=40.271616 bytes=13024410
480p 700k ssim=0.943916 psnr=36.033589 bytes=1761608
480p 1200k ssim=0.952615 psnr=36.652898 bytes=3066552
480p 2800k ssim=0.959179 psnr=37.085631 bytes=7308948
480p 5000k ssim=0.961340 psnr=37.209893 bytes=12962468
360p 700k ssim=0.932961 psnr=35.037344 bytes=1803998
360p 1200k ssim=0.938584 psnr=35.330524 bytes=3109855
360p 2800k ssim=0.943148 psnr=35.536487 bytes=7347336
360p 5000k ssim=0.944442 psnr=35.587053 bytes=12758625
رسم بياني للتشابه SSIM مع الأصل بعد تكبير كل نسخة إلى 1080p، لأربع دقات عند أربعة معدلات من 700 إلى 5000 كيلوبت. عند 700 كيلوبت تفوز 720p بقيمة 0.951 على 1080p بقيمة 0.948، ومن 1200 كيلوبت فما فوق تفوز 1080p حتى 0.994 عند 5000. ومنحنى 480p يتسطح عند 0.96 ومنحنى 360p عند 0.944 مهما زاد المعدل، و720p تتوقف عند 0.979
عند 700 كيلوبت فازت 720p، ومن 1200 كيلوبت فازت 1080p، والدقات الصغيرة لا تستفيد من البتات الزائدة

في المخرج أعلاه لاحظ التالي:

  • عند 700 كيلوبت فازت 720p على 1080p، أي أن البكسلات الزائدة في 1080p بهذا المعدل كلفت أكثر مما أضافت، وهذا ما شرحناه عن الغلاف المحدب.
  • من 1200 كيلوبت فما فوق فازت 1080p على كل الدقات، والسبب أن Big Buck Bunny رسوم متحركة بمساحات لونية ناعمة يسهل ضغطها، فيكفيها معدل منخفض نسبياً، وهذا يعني أن درجة 480p بمعدل 1200 في سلمنا ليست الأفضل لهذا المحتوى تحديداً، فنسخة 1080p أو 720p بنفس المعدل أوضح.
  • الدقات الصغيرة تصل إلى سقف لا تتجاوزه: 480p من 2800 إلى 5000 كيلوبت تحسنت من 0.959 إلى 0.961 فقط، و360p من 0.943 إلى 0.944، أي أن إعطاء دقة صغيرة معدلاً عالياً هدر خالص.
  • هذا القياس على شاشة 1080p، أما على شاشة هاتف عرضها بضع مئات من البكسلات فالفرق بين الدقات يقل كثيراً، ولهذا تستخدم المنصات الكبيرة مقياس VMAF الذي يأخذ ظروف العرض في الحساب، وشرحناه في منصة فيديو مثل Netflix.

والخلاصة العملية من هذا القياس أن السلم الثابت حل وسط معقول لمنصة صغيرة، لكنه لا يناسب كل محتوى بنفس الدرجة، فمحاضرة شرائح ثابتة تحتاج أقل بكثير من مشهد رياضي سريع، وإذا كانت مكتبتك متنوعة فقس على عينة من كل نوع قبل أن تثبت السلم.

نجرب العطل: التجزئة ترفض الدرجة 480p

بعد الترميز قمنا بالتجزئة إلى أجزاء من ثانيتين بنسخ الدفق، وكانت النسخة الأولى من الأمر دون الخيار -aspect:v 16:9، فرفض FFmpeg كتابة الحزمة:

[dash @ 0x7fd1d0ef9600] Conflicting stream aspect ratios values in Adaptation Set 1. Please ensure all adaptation sets have the same aspect ratio
[out#0/dash @ 0x7fd1d0abb6c0] Could not write header (incorrect codec parameters ?): Invalid argument
Command exited with non-zero status 234

والسبب أن 854÷480 تساوي 1.779 وليس 1.778 بالضبط، لأن 480 × 16 ÷ 9 = 853.33 ولا يوجد ثلث بكسل، وعرض الفيديو يجب أن يكون زوجياً، فاختار المرمز نسبة بكسل Sample Aspect Ratio تساوي 1280:1281 حتى تبقى الصورة 16:9 على الشاشة، بينما بقية الدرجات نسبة بكسلها 1:1. ومجموعة التكيف Adaptation Set في DASH تعد المشغل بأن كل نسخها بنفس نسبة العرض، فرفض FFmpeg أن يكتب قائمة تكذب. والحل أن نحدد نسبة العرض Display Aspect Ratio لكل الدفقات صراحة بالخيار -aspect:v 16:9، وهو يعمل مع نسخ الدفق، أو أن نضيف setdar=16/9 بعد التصغير عند الترميز. ولاحظ أن الخطأ ظهر عند التجزئة وليس عند الترميز، أي بعد 13 دقيقة من العمل، وهذا سبب إضافي لفصل الخطوتين.

التجزئة Packaging: ثانيتان وست ثوان من نفس الترميز

docker run --rm -v "$PWD:/w" --entrypoint sh bluenviron/mediamtx:1.21.1-ffmpeg -c 'sh /w/enc.sh package 2 seg2 && sh /w/enc.sh package 6 seg6 declared'
files: 317  bytes: 145157681
files: 117  bytes: 145146885

والتجزئة نفسها أخذت قرابة ثانيتين من زمن المعالج فقط، لأنها نسخ بايتات دون ترميز. وأجزاء الثانيتين أنتجت 317 ملفاً، 61 جزءاً لكل دفق من الدفقات الخمسة مع ملفات التهيئة والقوائم، وأجزاء الست ثوان أنتجت 117 ملفاً، بينما الحجم الكلي واحد تقريباً لأن البيانات نفسها. ولاحظ أن التخزين لا يتأثر بمدة الجزء، ولكن عدد الطلبات يتأثر: ثلاثة أضعاف الطلبات لكل مشاهد مع أجزاء الثانيتين.

أخطر سطر في الحزمة: BANDWIDTH

في قراءة القائمة الرئيسية لاحظنا أن قيمة BANDWIDTH لنسخة 1080p هي 4,073,321 مع أننا رمزناها بمعدل 5000 كيلوبت. فقمنا بقياس المعدل الفعلي لكل نسخة من أحجام أجزائها، المتوسط وأعلى جزء:

cd seg2
for s in 0 1 2 3 4; do
  ls -l chunk-stream$s-*.m4s | awk -v s=$s '{ t += $5; if ($5 > m) m = $5; n++ }
    END { printf "stream%d segments=%d avg=%.0f kbps peak2s=%.0f kbps\n", s, n, t*8/120/1000, m*8/2/1000 }'
done
for s in 0 1 2 3; do echo "stream$s first segment: $(( $(stat -c %s chunk-stream$s-00001.m4s) * 8 / 2 )) bit/s"; done
stream0 segments=61 avg=4907 kbps peak2s=6748 kbps
stream1 segments=61 avg=2760 kbps peak2s=3960 kbps
stream2 segments=61 avg=1184 kbps peak2s=1700 kbps
stream3 segments=61 avg=690 kbps peak2s=994 kbps
stream4 segments=61 avg=134 kbps peak2s=145 kbps
stream0 first segment: 4064472 bit/s
stream1 first segment: 1861380 bit/s
stream2 first segment: 704680 bit/s
stream3 first segment: 405980 bit/s

والمخرج يشرح كل شيء: قيمة BANDWIDTH التي كتبها FFmpeg في master.m3u8 هي معدل الجزء الأول فقط مضافاً إليه الصوت، فنسخة 1080p أعلنت 4.07 ميجابت بينما متوسطها الفعلي 4.9 وأعلى جزء فيها 6.75 ميجابت، أي أن القائمة تقلل المعدل الحقيقي بنسبة 40% عند الذروة. والسبب في كود المجزئ dashenc نفسه: عند نسخ الدفق لا يعرف FFmpeg المعدل المستهدف لأنه لم يرمز شيئاً، فيأخذ معدل الجزء الأول، ويكتب القائمة الرئيسية مرة واحدة بعد أول جزء ولا يعود إليها، ومقطعنا يبدأ بمشهد هادئ فالجزء الأول أصغر من المتوسط. أما قائمة DASH من نفس الأمر فتكتب من جديد في نهاية التجزئة، فحملت المتوسط الفعلي 4,904,924. والأسوأ أن FFmpeg حذرنا فعلاً، ولكننا كنا نشغله بالخيار -v error الذي يخفي التحذيرات، وعندما أعدنا التجزئة بالخيار -v warning ظهر التحذير لكل دفق:

[dash @ 0x7fc5dc3f6600] No bit rate set for stream 0
[dash @ 0x7fc5dc3f6600] No bit rate set for stream 1
[dash @ 0x7fc5dc3f6600] No bit rate set for stream 2
[dash @ 0x7fc5dc3f6600] No bit rate set for stream 3
[dash @ 0x7fc5dc3f6600] No bit rate set for stream 4

وهذا نفس الدرس الذي رأيناه مع الترجمة العربية في مقال FFmpeg: الأمر ينجح برمز خروج صفر، والمشكلة في سطر تحذير لم يقرأه أحد.

وقد يتساءل البعض: وما المشكلة إذا كانت القيمة أقل قليلاً؟ والإجابة في معيار HLS RFC 8216 نفسه، فهو يعرف BANDWIDTH بأنه أعلى معدل للأجزاء Peak Segment Bit Rate وليس المتوسط، ويقول صراحة إن القيمة غير الدقيقة قد تسبب توقف التشغيل. فالمشغل الذي يقيس سرعة 4.5 ميجابت سوف يرى أن نسخة 1080p تحتاج 4.07 فقط فيختارها، ثم يصل إلى جزء معدله 6.7 ميجابت فيتأخر ويفرغ المخزن. والحل أن نكتب القيمة الصحيحة، وفي FFmpeg يكفي عند نسخ الدفق أن نعطي كل دفق قيمة -b:v فيكتبها في القائمتين، وهذا ما يفعله الخيار declared في enc.sh بأعلى معدل قسناه لكل نسخة، فأصبحت القائمة:

#EXT-X-STREAM-INF:BANDWIDTH=6756816,RESOLUTION=1920x1080,CODECS="avc1.640028,mp4a.40.2",AUDIO="group_A1"
#EXT-X-STREAM-INF:BANDWIDTH=3966816,RESOLUTION=1280x720,CODECS="avc1.64001f,mp4a.40.2",AUDIO="group_A1"
#EXT-X-STREAM-INF:BANDWIDTH=1706816,RESOLUTION=854x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_A1"
#EXT-X-STREAM-INF:BANDWIDTH=1006816,RESOLUTION=640x360,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_A1"

ولاحظ أن الأرقام الجديدة للفيديو فقط مع هامش صغير يضيفه المجزئ، والمعيار يطلب أن تشمل الصوت أيضاً، وهذا ما سوف يصححه سكربت الأتمتة لاحقاً بحساب كل شيء من الأجزاء نفسها. وسمينا هذه الحزمة seg2fix، والآن عندنا حزمتان متطابقتان في كل بايت من الأجزاء، والفرق الوحيد بينهما أربعة أرقام في ملف نصي، وسوف نرى أثرها على المشاهد.

صفحة المشغل Player التي تسجل كل شيء

الآن نحتاج صفحة تشغل الحزمة وتسجل ما يفعله المشغل: متى بدأت الصورة، ومتى تغيرت الجودة، ومتى توقف الفيديو وكم ثانية، وكم بايت حمل من كل نسخة. وهذه الصفحة player.html، وتعمل مع المشغلين بحسب المعامل p في الرابط، وحملنا hls.js 1.7.3 وdash.js 5.2.1 إلى المجلد lib من npm:

<!doctype html>
<html lang="en">
<head><meta charset="utf-8"><title>abr lab player</title>
<script src="lib/hls.min.js"></script>
<script src="lib/dash.all.min.js"></script>
<style>body{font:15px system-ui;margin:16px;background:#111;color:#eee} video{width:960px;background:#000} #log{white-space:pre-wrap;font:13px Consolas,monospace;width:1040px}</style>
</head>
<body>
<video id="v" muted playsinline></video>
<div id="log"></div>
<script>
// ?p=hls|dash  &d=<package dir>
const q = new URLSearchParams(location.search), kind = q.get('p'), dir = q.get('d') || 'seg2';
const video = document.getElementById('v'), log = document.getElementById('log');
const t0 = performance.now(), now = () => +((performance.now() - t0) / 1000).toFixed(2);
const lab = window.lab = { startup: null, heights: [], stalls: [], samples: [], net: [] };
window.mark = (kbps) => lab.net.push([now(), kbps]);
let lastH = 0, stallAt = null;
video.addEventListener('playing', () => {
  if (lab.startup === null) lab.startup = now();
  if (stallAt !== null) { lab.stalls.push({ at: stallAt, seconds: +(now() - stallAt).toFixed(2) }); stallAt = null; }
});
video.addEventListener('waiting', () => { if (lab.startup !== null && !video.ended) stallAt = now(); });
let estimate = () => 0;
if (kind === 'hls') {
  const hls = new Hls(); window.player = hls;
  hls.loadSource(`/${dir}/master.m3u8`); hls.attachMedia(video);
  estimate = () => Math.round(hls.bandwidthEstimate / 1000);
} else {
  const p = dashjs.MediaPlayer().create(); window.player = p;
  p.initialize(video, `/${dir}/manifest.mpd`, true);
  estimate = () => { try { return Math.round(p.getAverageThroughput('video')); } catch { return 0; } };
}
video.play().catch(() => {});
// bytes downloaded per stream (chunk-streamN-*.m4s), from Resource Timing
window.segBytes = () => {
  const out = {};
  for (const e of performance.getEntriesByType('resource')) {
    const m = e.name.match(/chunk-stream(\d)-(\d+)\.m4s/); if (!m) continue;
    const k = 'stream' + m[1]; out[k] = out[k] || { segments: 0, bytes: 0 };
    out[k].segments++; out[k].bytes += e.encodedBodySize || e.transferSize || 0;
  }
  return out;
};
performance.setResourceTimingBufferSize(5000);
let tick = 0, lastCT = -1;
lab.frozen = 0;
setInterval(() => {
  const h = video.videoHeight;
  if (lab.startup !== null && !video.ended && video.currentTime === lastCT) lab.frozen = +(lab.frozen + 0.25).toFixed(2);
  lastCT = video.currentTime;
  const q = video.getVideoPlaybackQuality(); lab.dropped = [q.droppedVideoFrames, q.totalVideoFrames];
  if (h && h !== lastH) { lab.heights.push({ t: now(), video_time: +video.currentTime.toFixed(1), height: h }); lastH = h; }
  const b = video.buffered.length ? +(video.buffered.end(video.buffered.length - 1) - video.currentTime).toFixed(1) : 0;
  if (++tick % 4 === 0) lab.samples.push([now(), h, b, estimate()]);
  log.textContent = `${kind} ${dir}  t=${now()}s  video=${video.currentTime.toFixed(1)}s  height=${h}  buffer=${b}s  estimate=${estimate()} kbps\n`
    + 'switches: ' + lab.heights.map(x => `${x.t}s→${x.height}p`).join('  ') + '\nstalls: ' + JSON.stringify(lab.stalls) + '  startup: ' + lab.startup + ' s';
}, 250);
</script>
</body>
</html>

في الصفحة أعلاه لاحظ التالي:

  • التوقف يقاس من حدث waiting الذي يطلقه عنصر الفيديو عندما يفرغ المخزن، إلى حدث playing عندما يعود، وهذه نفس الطريقة التي تحسب بها خدمات التحليلات نسبة التوقف.
  • الدالة segBytes تقرأ كل طلب جزء من واجهة توقيت الموارد Resource Timing وتجمع البايتات لكل نسخة من رقمها في اسم الملف، فنعرف كم حمل المشغل من كل جودة، وليس فقط ما عرضه.
  • getVideoPlaybackQuality() يعطي عدد الإطارات التي أسقطها المتصفح لأنه لم يلحق بفكها، وهذا يفرق بين توقف سببه الشبكة وتقطع سببه المعالج.

التحكم في سرعة الشبكة Throttling أثناء التشغيل

أداة Network Throttling في أدوات المطور في Chrome تعمل يدوياً، أما نحن فنريد أن نغير السرعة في ثوان محددة من كل تجربة وأن نكررها، فاستخدمنا نفس الخاصية عبر الأمر Network.emulateNetworkConditions في بروتوكول أدوات المطور، وهو نفس ما تستدعيه مكتبات مثل Puppeteer. وهذا السكربت abrtest.mjs، والدالة launch فيه من ملف مساعد صغير عندنا يشغل Chrome دون واجهة بالخيار --remote-debugging-port ويرسل الأوامر عبر WebSocket:

// Drives the lab player in headless Chrome and changes the network speed during playback (Chrome DevTools Protocol).
//   node abrtest.mjs <hls|dash> <seg2|seg6> <profile> [screenshot.png]
import { launch } from './browser.mjs';
import { appendFileSync } from 'node:fs';
const save = (line) => appendFileSync(process.env.OUT || 'results.jsonl', line + '\n');
const [kind, dir, profile, shot] = process.argv.slice(2);
const PROFILES = {
  // [seconds after start, download kbit/s, latency ms]; 0 = no throttling
  drop:    [[0, 8000, 20], [15, 1500, 40], [30, 400, 80], [45, 8000, 20]],
  fast:    [[0, 0, 0]],
  mobile3: [[0, 3000, 60]],
  cliff:   [[0, 8000, 20], [12, 300, 120]],
};
const RUN = +(process.env.RUN || 60000);
const b = await launch({ port: +(process.env.CDP || 19203), width: 1100, height: 760 });
try {
  await b.send('Network.enable');
  await b.send('Network.setCacheDisabled', { cacheDisabled: true });
  const steps = PROFILES[profile];
  const apply = async ([, kbps, lat]) => b.send('Network.emulateNetworkConditions', kbps
    ? { offline: false, latency: lat, downloadThroughput: kbps * 1000 / 8, uploadThroughput: 1000000 }
    : { offline: false, latency: 0, downloadThroughput: -1, uploadThroughput: -1 });
  await apply(steps[0]);
  const start = Date.now();
  await b.goto(`http://127.0.0.1:19191/player.html?p=${kind}&d=${dir}`, { wait: 200 });
  for (const s of steps.slice(1)) { const wait = s[0] * 1000 - (Date.now() - start); if (wait > 0) await b.sleep(wait); await apply(s); await b.evaluate(`window.mark && window.mark(${s[1]})`).catch(() => {}); }
  const end = RUN - (Date.now() - start); if (end > 0) await b.sleep(end);
  const lab = JSON.parse(await b.evaluate('JSON.stringify(window.lab)'));
  lab.bytes = JSON.parse(await b.evaluate('JSON.stringify(window.segBytes())'));
  lab.video_time = await b.evaluate('document.getElementById("v").currentTime');
  save(JSON.stringify({ kind, dir, profile, ...lab }));
  if (shot) { await b.evaluate("document.getElementById('v').pause(); if (window.player.stopLoad) window.player.stopLoad(); 0"); await b.sleep(500); }
  if (shot) await b.shot(shot, { selector: 'body', pad: 0 });
} finally { await b.close(); }

والملفات الأربعة للشبكة تمثل حالات حقيقية يمر بها الطالب:

  • drop: يبدأ على Wi-Fi بسرعة 8 ميجابت، ثم يخرج من البيت فتصبح 1.5 ميجابت، ثم يدخل مكاناً ضعيف التغطية بسرعة 400 كيلوبت، ثم يعود إلى 8 ميجابت، كل مرحلة 15 ثانية.
  • mobile3: بيانات هاتف ثابتة بسرعة 3 ميجابت وزمن وصول 60 ميلي ثانية طوال الدقيقة.
  • cliff: 8 ميجابت ثم سقوط مفاجئ إلى 300 كيلوبت بعد 12 ثانية، أقل من أدنى درجة في السلم.
  • fast: دون أي تقييد، لنرى كم يحمل كل مشغل عندما لا يوجد ما يمنعه.

وقدمنا مجلد التجربة من سيرفر ملفات ثابتة على نفس الجهاز بنفس ترويسات nginx التي سوف نذكرها في قسم التوصيل، وشغلنا كل تركيبة من المشغل والحزمة وملف الشبكة لمدة 60 ثانية، وكررنا التركيبات المهمة مرتين أو ثلاثاً.

النتائج Results: أربعة أرقام في ملف نصي

هذه نتائج hls.js مع الحزمتين المتطابقتين في الأجزاء، seg2 بالقائمة كما كتبها FFmpeg وseg2fix بأعلى معدل مقاس:

الشبكةالقائمةالمحاولاتأول جودةزمن البدءالتوقفات
dropFFmpeg21080p2.2 و5.4 ثانية3 توقفات في كل محاولة، بمجموع 19.2 و9.8 ثانية
dropالمصححة3720p1.6 إلى 2.2 ثانيةلا يوجد
mobile3FFmpeg31080p6.8 إلى 9.8 ثانية1 أو 2 في كل محاولة، من 3.0 إلى 10.8 ثانية
mobile3المصححة3720p2.4 إلى 4.6 ثانيةلا يوجد

والنتيجة واضحة: نفس البايتات ونفس المشغل، والفرق الوحيد قيمة BANDWIDTH، فتوقف الفيديو مع قائمة FFmpeg في كل محاولة، ولم يتوقف مرة واحدة مع القائمة المصححة. والصورة التالية تبين محاولتين على ملف drop: مع القائمة الخاطئة بقي المخزن قريباً من الصفر طوال الوقت لأن المشغل كان يختار دائماً نسخة أثقل مما يظن، ومع القائمة الصحيحة امتلأ المخزن إلى قرابة 25 ثانية في الدقائق الأولى وعبر به مرحلة 400 كيلوبت كلها دون أن يفرغ.

رسم بياني لمحاولتين من التجربة بمشغل hls.js على ملف شبكة يبدأ بسرعة 8 ميجابت ثم 1.5 ميجابت عند الثانية 15 ثم 400 كيلوبت عند الثانية 30 ثم 8 ميجابت عند الثانية 45. في الأعلى الجودة المعروضة: الخط الأحمر للقائمة كما كتبها FFmpeg يبدأ 1080p ثم 480p ثم 720p ثم ينزل إلى 360p عند الثانية 12 ويبقى عليها، والخط الأخضر للقائمة المصححة يبدأ 720p ثم 480p من الثانية 7 حتى 46 ثم 360p. وفي الأسفل المخزن بالثواني: الأحمر قريب من الصفر طوال الوقت مع ثلاثة توقفات عند الثواني 16 و31 و41 بمجموع 9.8 ثانية، والأخضر يرتفع إلى 25 ثانية ثم ينزل إلى 19 في مرحلة 400 كيلوبت ثم يعود إلى 30 دون أي توقف
القائمة الخاطئة أبقت المخزن فارغاً، والصحيحة ملأته بخمس وعشرين ثانية عبرت بها الشبكة البطيئة

ولماذا بدأ المشغل بنسخة 1080p مع قائمة FFmpeg وبنسخة 720p مع المصححة؟ قمنا بقراءة كود hls.js لنفهم ذلك، فوجدنا أنه إذا لم تحدد تقديراً أولياً للسرعة بنفسك، فإنه يرفع تقديره الأول إلى معدل أول نسخة في القائمة، بحد أعلى 5 ميجابت (abrEwmaDefaultEstimateMax). وFFmpeg يكتب نسخة 1080p أولاً، فمع قائمة FFmpeg كان التقدير الأول 4.07 ميجابت، وهو بالضبط ما تعلنه 1080p فاختارها، وعلى شبكة 3 ميجابت أخذ جزؤها الأول بحجم 1 ميجابايت قرابة ثلاث ثوان، فتأخر البدء إلى ما بين 6.8 و9.8 ثانية ثم توقف بعد ذلك. ومع القائمة المصححة كان التقدير الأول 5 ميجابت، فاختار 720p التي تعلن 3.97 ميجابت، وبدأ في ثانيتين ونصف. أي أن القيمة الخاطئة أفسدت القرار مرتين: عند البدء وأثناء التشغيل. ولاحظ من هذا أيضاً أن ترتيب النسخ في القائمة يؤثر، فإذا أردت بداية أسرع على الهواتف فاكتب درجة متوسطة أولاً، أو حدد startLevel أو abrEwmaDefaultEstimate في إعدادات المشغل.

ماذا عن مشغل dash.js؟

قائمة DASH من FFmpeg لم تحمل نفس الخطأ، لأنها كتبت المتوسط الفعلي وليس الجزء الأول، ومع ذلك فالمتوسط أقل من الذروة، فشغلنا dash.js مع القائمتين أيضاً. والفرق الذي ظهر لم يكن بين القائمتين وإنما بين المشغلين: dash.js بدأ دائماً بأقل نسخة 360p، وكان زمن البدء بين 0.6 و3.2 ثانية، وبقي أغلب الوقت على 360p و480p على ملفي drop وmobile3، ولم يصعد إلى 720p إلا لثوان قليلة في ثلاث محاولات، بينما بدأ hls.js من 720p. ومن 10 محاولات لdash.js على هذين الملفين انتهت 7 دون أي توقف، أما الثلاث التي توقفت فكان المتصفح فيها يسقط إطارات كثيرة، بين 120 و347 إطاراً، أي أن جزءاً من التوقف كان من المعالج المشغول وليس من الشبكة. وهذا يعني أن dash.js أكثر حذراً بإعداداته الافتراضية: جودة أقل في المتوسط مقابل توقف أقل، وهذا الاختيار نفسه هو ما تضبطه في أي مشغل.

واستبعدنا من كل الجداول ثلاث محاولات لم يبدأ فيها التشغيل خلال 20 ثانية لأن الجهاز كان مشغولاً بأعمال أخرى في تلك اللحظة، وهي حالة لا علاقة لها بالشبكة.

مدة الجزء Segment Duration في التجربة: ماذا رأينا؟

شغلنا الحزمة seg6، وهي نفس الترميز بأجزاء من ست ثوان وبالقيم المصححة، على شبكة 3 ميجابت، وقارناها بالحزمة seg2fix:

المشغلمدة الجزءزمن البدءالتوقفات
hls.js2 ثانية2.4 إلى 4.6 ثانيةلا يوجد في 3 محاولات
hls.js6 ثوان8.6 ثانية في المحاولتينلا يوجد في محاولتين
dash.js2 ثانية0.9 إلى 3.2 ثانيةلا يوجد في محاولتين من 3
dash.js6 ثوان6.9 و7.4 ثانية3 توقفات قصيرة في محاولة من اثنتين، بمجموع 4.1 ثانية

والفرق الأوضح في زمن البدء: ثلاثة أضعاف تقريباً، لأن المشغل لا يعرض أول صورة حتى يكتمل أول جزء، والجزء من ست ثوان بنسخة 720p قرابة 1.9 ميجابايت يحتاج خمس ثوان على 3 ميجابت. وعلى ملف drop توقف hls.js مع أجزاء الست ثوان مرتين بمجموع 12.8 ثانية، وجاء التوقفان عند لحظتي انخفاض السرعة بالضبط، الثانية 15 والثانية 31، فالجزء الذي بدأ تحميله قبل الانخفاض بست ثوان من البيانات يأخذ أربعة أضعاف وقته بعد الانخفاض، والمشغل لا يقرر من جديد حتى ينتهي منه أو يتخلى عنه، بينما لم يتوقف مع أجزاء الثانيتين في ثلاث محاولات. ولهذا نوصي بأجزاء من ثانيتين إلى أربع ثوان لمحتوى يشاهد كثيراً على الهواتف، وتقبل الطلبات الإضافية ثمناً لذلك.

نجرب العطل: الاتصال أقل من أدنى درجة Lowest Rung

في ملف cliff تسقط السرعة إلى 300 كيلوبت، وأدنى درجة في سلمنا 360p تعلن قرابة مليون بت في الثانية، فلا توجد نسخة يستطيع المشغل أن يختارها. والنتيجة كما توقعنا: hls.js توقف 4 مرات بمجموع 27.7 ثانية مع قائمة FFmpeg، وتجمد قرابة 33 ثانية مع القائمة المصححة، وdash.js توقف 3 إلى 5 مرات بمجموع 20 إلى 30 ثانية، أي أن الطالب قضى نصف الدقيقة ينظر إلى دائرة التحميل. ولا يوجد مشغل يحل هذا، فالحل في السلم نفسه: أضفنا درجة 416×234 بمعدل 200 كيلوبت بالأمر enc.sh low، وأخذ ترميزها 34 ثانية معالج فقط، وحجمها 3 ميجابايت للدقيقتين كاملتين، ثم جزأنا الحزمة seg2low بالأمر enc.sh packagelow 2 seg2low وأعدنا نفس الاختبار.

المشغلدون الدرجة 234pمع الدرجة 234p
hls.js4 توقفات بمجموع 27.7 ثانية، وتجمد 33 ثانية في المحاولة الثانيةتوقف واحد 2.6 ثانية في محاولة، ولا شيء في الأخرى
dash.js3 إلى 5 توقفات بمجموع 20 إلى 30 ثانيةلا شيء في محاولتين، و5 توقفات قصيرة بمجموع 6.9 ثانية في الثالثة

والصورة التالية من التجربة نفسها، بعد أن نزل dash.js إلى نسخة 234p عند الثانية 28: الصورة أقل حدة بوضوح، ولكنها تتحرك، والسطر الأخير يقول إن التوقفات صفر.

لقطة حقيقية من صفحة المشغل في التجربة أثناء تشغيل فيلم Big Buck Bunny بمشغل dash.js على شبكة 300 كيلوبت، والصورة أقل حدة لأنها نسخة 234p، وتحتها سطر السجل: dash seg2low عند الثانية 58 والفيديو عند 52.7 ثانية والارتفاع 234 والمخزن 5.2 ثانية والتقدير 163 كيلوبت، والتبديلات من 360p إلى 480p ثم 360p ثم 234p عند الثانية 28، والتوقفات قائمة فارغة وزمن البدء 0.86 ثانية
جودة 234p على 300 كيلوبت: أقل حدة، لكن الطالب يكمل المحاضرة. لقطة من Big Buck Bunny © Blender Foundation | peach.blender.org، CC BY 3.0

وهذا يقودنا إلى قاعدة مهمة في تصميم السلم: الدرجة الدنيا لا تقاس بجودتها وإنما بأنها تمنع التوقف، والطالب الذي يرى صورة ضبابية مع صوت واضح للمدرب يكمل المحاضرة، أما الذي يرى دائرة التحميل فيغلق الصفحة. وفي المحاضرات تحديداً الصوت أهم من الصورة، فالدرجة الدنيا مع صوت 128 كيلوبت كاملة تكفي لمتابعة الشرح.

على الشبكة السريعة: كم يحمل كل مشغل Player؟

وفي ملف fast دون أي تقييد اختار المشغلان 1080p مباشرة ولم يتوقفا، ولكن الفرق كان في الكمية: بعد قرابة 50 ثانية من التشغيل كان hls.js قد حمل 62 جزءاً من نسخة 1080p بحجم 73.6 ميجابايت، أي الدقيقتين كاملتين، بينما حمل dash.js 38 جزءاً بحجم 46.2 ميجابايت، أي ما شاهده مع مخزن قرابة 30 ثانية أمامه. والسبب في hls.js أن حد المخزن عنده بالحجم وليس بالزمن فقط، فهو يحمل حتى 30 ثانية على الأقل ثم يستمر حتى 60 ميجابايت، وسوف نعود إلى أثر هذا على التكلفة.

أتمتة التحويل Automation: كل فيديو جديد يصبح حزمة جاهزة

كل ما فعلناه في التجربة كان يدوياً: ترميز، ثم تجزئة، ثم قياس، ثم تصحيح القائمة. وفي المنصة الحقيقية يرفع المدربون المحاضرات طوال اليوم، ولا يوجد مهندس يجلس أمام كل ملف. والطريقة البسيطة للأتمتة أن تضيف استدعاء FFmpeg في نفس الكود الذي يستقبل الرفع، وهذه أسوأ الطرق على الإطلاق، والسبب أن الترميز يأخذ دقائق من المعالج لكل دقيقة فيديو كما رأينا، فيبقى طلب الرفع معلقاً، وإذا رفع ثلاثة مدربين في نفس الوقت توقف السيرفر عن خدمة الطلاب. والحل الأنسب أن يكون التحويل عملية منفصلة تأخذ الملفات من مكان وتضع الحزم في مكان آخر، وأبسط صورة لها مجلد مراقب Watch Folder: سكربت يراقب مجلد الإدخال، ويحول كل ملف جديد، ويضع الحزمة في مجلد الإخراج.

والصورة التالية تبين المسار الذي يمر به كل ملف في السكربت الذي سوف نكتبه، من لحظة الرفع إلى أن تظهر الحزمة، ومسار الفشل الذي لا يقل أهمية عن مسار النجاح:

رسم لمسار ملف المحاضرة في سكربت المجلد المراقب: الملف in/lecture-01.mov، ثم التأكد من ثبات حجمه بعد ثانيتين، ثم ffprobe يقرأ الارتفاع 1080 ومعدل الإطارات 24، ثم اختيار الدرجات وإسقاط الأعلى من المصدر، ثم ffmpeg يرمز ويجزئ في مجلد out/.work، ثم تصحيح BANDWIDTH من أحجام الأجزاء مع الصوت وإضافة AVERAGE-BANDWIDTH، ثم نشر ذري بأمر mv واحد إلى out/lecture-01 وفيه master.m3u8 وmanifest.mpd و92 ملفاً ثم CDN. وفي الأسفل مسار الفشل: أي خطأ ينقل الملف إلى in/.done باسم ينتهي بـ .failed ولا يظهر شيء في out
الحزمة تظهر كاملة أو لا تظهر، والملف المعطوب لا يعاد إلى الأبد

وقمنا بكتابة السكربت التالي auto.sh، وفيه كل ما تعلمناه من التجربة: السلم، والإطارات المفتاحية، وعدم تكبير الفيديو الصغير، وتصحيح BANDWIDTH من الأجزاء نفسها، والنشر الذري Atomic Publish حتى لا يرى المشغل حزمة نصف مكتملة:

#!/bin/sh
# Watch folder packager: every new file in /in becomes an ABR package (CMAF segments, DASH + HLS) in /out/<name>/.
# Only rungs at or below the source height are made (no upscaling), and BANDWIDTH in master.m3u8 is rewritten
# from the real segment sizes, because FFmpeg writes it from the first segment only.
set -u
IN=/in; OUT=/out; WORK=/out/.work                       # same disk as /out, so the final mv is a rename
LADDER="1080:1920:5000 720:1280:2800 480:854:1200 360:640:700"   # height:width:kbps
mkdir -p "$WORK" "$IN/.done"

# peak and average bit rate (bit/s) of one media playlist, from segment sizes and EXTINF durations.
# RFC 8216 measures the peak over runs of 0.5 to 1.5 target durations, so a segment shorter than half the
# target (the one-frame tail of a video) is measured together with the segment before it.
rates() {
  awk -v d="$1" '/^#EXT-X-TARGETDURATION:/ { split($0, t, ":"); half = t[2] / 2; next }
       /^#EXTINF:/ { split($0, a, /[:,]/); dur = a[2]; next }
       /^[^#]/ && dur > 0 { cmd = "stat -c %s \"" d "/" $0 "\""; cmd | getline sz; close(cmd)
                            r = (dur < half) ? (sz + psz) * 8 / (dur + pdur) : sz * 8 / dur
                            if (r > peak) peak = r; bytes += sz; total += dur; psz = sz; pdur = dur; dur = 0 }
       END { printf "%d %d\n", peak, bytes * 8 / total }' "$1/$2"
}

# RFC 8216: BANDWIDTH is the peak segment bit rate (video + audio); also add AVERAGE-BANDWIDTH
fix_master() {
  dir=$1
  audio=$(grep -o 'URI="[^"]*"' "$dir/master.m3u8" | head -1 | cut -d'"' -f2)
  set -- $(rates "$dir" "$audio"); ap=$1; aa=$2
  : > "$dir/master.tmp"
  while IFS= read -r line; do
    case "$line" in
      "#EXT-X-STREAM-INF:"*) inf=$line ;;
      media_*.m3u8) set -- $(rates "$dir" "$line")
                    echo "$inf" | sed "s/BANDWIDTH=[0-9]*/BANDWIDTH=$(($1 + ap)),AVERAGE-BANDWIDTH=$(($2 + aa))/" >> "$dir/master.tmp"
                    echo "$line" >> "$dir/master.tmp" ;;
      *) echo "$line" >> "$dir/master.tmp" ;;
    esac
  done < "$dir/master.m3u8"
  mv "$dir/master.tmp" "$dir/master.m3u8"
}

package() {
  src=$1; name=$(basename "$src"); name=${name%.*}
  h=$(ffprobe -v error -select_streams v:0 -show_entries stream=height -of default=nw=1:nk=1 "$src" 2>/dev/null)
  [ -n "$h" ] || { echo "$name: no video stream"; return 1; }
  fps=$(ffprobe -v error -select_streams v:0 -show_entries stream=r_frame_rate -of default=nw=1:nk=1 "$src")
  gop=$(echo "$fps" | awk -F/ '{ printf "%d", 2 * $1 / $2 + 0.5 }')        # one keyframe every 2 s
  graph=""; maps=""; rates=""; i=0
  for r in $LADDER; do
    rh=${r%%:*}; rest=${r#*:}; rw=${rest%%:*}; kb=${rest#*:}
    [ "$rh" -gt "$h" ] && continue
    graph="$graph[s$i]scale=$rw:$rh,setdar=16/9[v$i];"
    maps="$maps -map [v$i]"
    rates="$rates -b:v:$i ${kb}k -maxrate:v:$i $((kb * 107 / 100))k -bufsize:v:$i $((kb * 2))k"
    i=$((i + 1))
  done
  [ "$i" -gt 0 ] || { echo "$name: ${h}p is below the lowest rung"; return 1; }
  outs=""; n=0; while [ $n -lt $i ]; do outs="$outs[s$n]"; n=$((n + 1)); done
  tmp="$WORK/$name"; rm -rf "$tmp"; mkdir -p "$tmp"
  start=$(date +%s)
  ffmpeg -hide_banner -v error -nostdin -y -i "$src" -filter_complex "[0:v]split=$i$outs;${graph%;}" $maps -map '0:a:0?' \
    -c:v libx264 -preset veryfast -profile:v high -pix_fmt yuv420p -g "$gop" -keyint_min "$gop" -sc_threshold 0 $rates \
    -c:a aac -b:a 128k -ac 2 -f dash -seg_duration 2 -use_template 1 -use_timeline 0 \
    -adaptation_sets "id=0,streams=v id=1,streams=a" -hls_playlist 1 "$tmp/manifest.mpd" \
    || { echo "$name: ffmpeg failed"; return 1; }
  [ -s "$tmp/master.m3u8" ] && [ -s "$tmp/manifest.mpd" ] || { echo "$name: manifests missing"; return 1; }
  fix_master "$tmp"
  rm -rf "$OUT/$name"; mv "$tmp" "$OUT/$name"                 # publish only a complete package
  echo "$name: ${h}p source, $i renditions, $(( $(date +%s) - start )) s, $(ls "$OUT/$name" | wc -l) files"
}

echo "watching $IN"
while true; do
  for f in "$IN"/*; do
    [ -f "$f" ] || continue
    s1=$(stat -c %s "$f"); sleep 2; s2=$(stat -c %s "$f")
    [ "$s1" = "$s2" ] || continue                               # still being copied
    if package "$f"; then mv "$f" "$IN/.done/"; else mv "$f" "$IN/.done/$(basename "$f").failed"; fi
  done
  sleep 3
done

في السكربت أعلاه لاحظ التالي:

  • السلم في متغير واحد LADDER، وكل درجة أعلى من ارتفاع المصدر تسقط، فمحاضرة مسجلة بدقة 720p لا تحصل على نسخة 1080p مكبرة لا تضيف أي تفصيل وتأخذ أكبر حجم في الحزمة.
  • الفاصل بين الإطارات المفتاحية يحسب من معدل الإطارات الفعلي للمصدر، فيكون ثانيتين بالضبط سواء كان الفيديو 24 أو 30 أو 60 إطاراً في الثانية، بدلاً من رقم ثابت مثل 48 يصبح 1.6 ثانية في فيديو 30 إطاراً.
  • -map '0:a:0?' بعلامة الاستفهام تجعل الصوت اختيارياً، فتسجيل الشاشة دون ميكروفون لا يفشل.
  • الدالة fix_master تعيد كتابة BANDWIDTH لكل نسخة بأعلى معدل لأجزائها مضافاً إليه أعلى معدل لأجزاء الصوت، كما يطلب المعيار، وتضيف AVERAGE-BANDWIDTH بالمتوسط، ولاحظ أن هذا ضروري حتى عند الترميز المباشر، لأن FFmpeg يكتب حينها المعدل المستهدف 5000 كيلوبت وهو المتوسط وليس الذروة.
  • العمل كله في مجلد .work على نفس القرص، ثم mv واحد يجعل الحزمة تظهر كاملة دفعة واحدة، لأن إعادة التسمية على نفس نظام الملفات عملية ذرية، بينما النسخ بين قرصين ليس كذلك.
  • السكربت ينتظر حتى يثبت حجم الملف ثانيتين قبل أن يبدأ، حتى لا يحول ملفاً ما زال يرفع، ثم ينقل الأصل إلى .done، أو يضيف له .failed إذا فشل، فلا يعيد محاولة نفس الملف المعطوب إلى الأبد.

تشغيل السكربت Script: ثلاثة ملفات وخطآن قبل النجاح

شغلنا السكربت في Container من نفس ال Docker Image، مع مجلدين للإدخال والإخراج، ثم نسخنا إلى مجلد الإدخال ثلاثة ملفات: محاضرة 1080p مدتها 30 ثانية، ومحاضرة 720p مدتها 20 ثانية، وملف نصي اسمه notes.mp4 يمثل رفعاً خاطئاً:

docker run -d --name arabroot-lab-abr-auto -v "$PWD/in:/in" -v "$PWD/out:/out" -v "$PWD/auto.sh:/auto.sh:ro" \
  --entrypoint sh bluenviron/mediamtx:1.21.1-ffmpeg /auto.sh
cp lecture-01.mov lecture-02-720p.mp4 notes.mp4 in/
docker logs -f arabroot-lab-abr-auto

وفي المحاولة الأولى فشل الملفان الحقيقيان، وهذا جزء من السجل:

watching /in
sh: 1080,: bad number
sh: 1080,: bad number
sh: 1080,: bad number
sh: 1080,: bad number
[dash @ 0x7ff7e4e07340] Conflicting stream aspect ratios values in Adaptation Set 1. Please ensure all adaptation sets have the same aspect ratio
...
lecture-01: ffmpeg failed
lecture-02-720p: ffmpeg failed
notes: no video stream

والسجل فيه خطآن من نوعين مختلفين:

  • «1080,: bad number»: كتبنا في النسخة الأولى -of csv=p=0 لقراءة الارتفاع، فأعاد ffprobe القيمة 1080, بفاصلة في آخرها، لأن دفق الفيديو في ملف MOV يحمل بيانات إضافية تظهر كعمود فارغ، ففشلت مقارنة الأرقام في [ "$rh" -gt "$h" ]. والأخطر أن السكربت لم يتوقف، فالشرط الفاشل يعني أن كل الدرجات ستدخل السلم، أي أن ملف 720p كان سيكبر إلى 1080p لو نجح الترميز. والحل الصيغة -of default=nw=1:nk=1 التي تطبع القيمة وحدها.
  • نسبة العرض مرة أخرى: كتبنا setsar=1 بعد التصغير، فأصبحت نسخة 854×480 بنسبة عرض 1.779 بدلاً من 16:9، ورفض المجزئ الحزمة بنفس الرسالة التي رأيناها مع نسخ الدفق. والحل setdar=16/9، أي أن نثبت نسبة العرض ونترك نسبة البكسل تتغير.

ولاحظ أن السكربت تصرف بشكل صحيح رغم الأخطاء: لم يظهر أي مجلد في مجلد الإخراج، لأن العمل كان في .work، ونقل الملفات الثلاثة إلى .done بالامتداد .failed، فلم يعد محاولتها مرة بعد مرة. وبعد التصحيح أعدنا نسخ الملفات:

watching /in
lecture-01: 1080p source, 4 renditions, 98 s, 92 files
lecture-02-720p: 720p source, 3 renditions, 36 s, 51 files
notes: no video stream

ومحاضرة 720p حصلت على ثلاث درجات فقط دون 1080p، والملف النصي رفض برسالة واضحة. ولكن عندما قرأنا القائمة الرئيسية للمحاضرة الأولى وجدنا مشكلة ثالثة في الأرقام نفسها:

#EXT-X-STREAM-INF:BANDWIDTH=8852490,AVERAGE-BANDWIDTH=4890133,RESOLUTION=1920x1080,...
#EXT-X-STREAM-INF:BANDWIDTH=11275703,AVERAGE-BANDWIDTH=2792745,RESOLUTION=1280x720,...
#EXT-X-STREAM-INF:BANDWIDTH=12637740,AVERAGE-BANDWIDTH=1266687,RESOLUTION=854x480,...
#EXT-X-STREAM-INF:BANDWIDTH=4515053,AVERAGE-BANDWIDTH=791079,RESOLUTION=640x360,...

نسخة 480p تعلن ذروة 12.6 ميجابت، وهذا غير ممكن لنسخة متوسطها 1.27 ميجابت. وعندما قرأنا آخر قائمة الوسائط وجدنا السبب: المحاضرة مدتها 30.04 ثانية، فبقي في النهاية جزء فيه إطار واحد مدته 0.0417 ثانية، وهذا الإطار مفتاحي بحجم 58 كيلوبايت، فإذا قسمت حجمه على مدته خرج معدل 11 ميجابت. والمعيار عالج هذه الحالة بالضبط، فهو يقيس الذروة على مجموعات أجزاء متتالية مدتها بين نصف ومرة ونصف المدة المستهدفة، وليس على كل جزء وحده، فأضفنا للدالة rates أن الجزء الأقصر من نصف المدة يقاس مع الجزء الذي قبله، وأعدنا تحويل المحاضرة:

lecture-01: 1080p source, 4 renditions, 50 s, 92 files
#EXT-X-STREAM-INF:BANDWIDTH=6773124,AVERAGE-BANDWIDTH=4884402,RESOLUTION=1920x1080,...
#EXT-X-STREAM-INF:BANDWIDTH=3825868,AVERAGE-BANDWIDTH=2794187,RESOLUTION=1280x720,...
#EXT-X-STREAM-INF:BANDWIDTH=1612588,AVERAGE-BANDWIDTH=1265729,RESOLUTION=854x480,...
#EXT-X-STREAM-INF:BANDWIDTH=1049948,AVERAGE-BANDWIDTH=791234,RESOLUTION=640x360,...

والأرقام الآن منطقية: ذروة 1080p هي 6.77 ميجابت ومتوسطها 4.88، وهي قريبة جداً مما قسناه يدوياً على المقطع الأطول. وللمقارنة كتب FFmpeg في قائمة DASH لنفس الحزمة القيم المستهدفة 5000000 و2800000 و1200000 و700000، لأنه هذه المرة رمز بنفسه فعرف المعدل المستهدف، ولكن المستهدف متوسط وليس ذروة، فالتصحيح ما زال ضرورياً حتى عند الترميز المباشر. ولاحظ أن زمن التحويل نزل من 98 إلى 50 ثانية لنفس الملف، والفرق لا علاقة له بالسكربت، وإنما بأن الجهاز كان مشغولاً بأعمال أخرى في المرة الأولى، وهذا سبب إضافي لأن تقيس سعة التحويل بزمن المعالج وليس بالزمن الفعلي.

حذف التجربة Cleanup

docker rm -f arabroot-lab-abr-auto
rm -rf seg2 seg2fix seg6 seg2low grid in out ladder.mkv low.mkv bbb120.mov big_buck_bunny_1080p_h264.mov*

وهذا السكربت كاف لمنصة صغيرة على سيرفر واحد، ولكن له حدود يجب أن تعرفها: يحول ملفاً واحداً في كل مرة، وإذا توقف السيرفر في منتصف التحويل يبقى الملف في مجلد الإدخال ويبدأ من الصفر، ولا يوجد تقرير بالتقدم للمدرب. وعندما تكبر المنصة تنتقل إلى طابور Queue وعدة Workers وتخزين كائنات، كما بنيناه في منصة فيديو مثل Netflix، أو إلى أداة جاهزة تدير التحويل لمكتبة كاملة بقواعد وواجهة ومتابعة، مثل Tdarr الذي سوف نشرحه في المقال التالي إن شاء الله.

التوصيل Delivery: ملفات ثابتة بقواعد Cache مختلفة

بعد أن تكتمل الحزمة يصبح توصيلها مسألة ملفات ثابتة، ولكن هناك أربعة أشياء صغيرة إذا أخطأت فيها تعطل البث في أجهزة معينة دون غيرها، أو ترفع فاتورة ال CDN دون أن تدري:

  • أنواع الملفات MIME Types: القوائم .m3u8 بالنوع application/vnd.apple.mpegurl، و.mpd بالنوع application/dash+xml، والأجزاء .m4s بالنوع video/iso.segment أو video/mp4. وبعض المشغلات تتسامح مع النوع الخاطئ وبعض أجهزة التلفاز لا تتسامح، فلا تعتمد على أن الصفحة عملت في متصفحك.
  • التخزين المؤقت Cache: الأجزاء لا تتغير أبداً بعد كتابتها، فاجعلها تخزن سنة كاملة بالترويسة Cache-Control: public, max-age=31536000, immutable، أما القوائم فقد تعيد كتابتها، كما فعلنا عندما صححنا BANDWIDTH، فاجعل مدتها قصيرة أو no-cache. وإذا عكست القاعدة فسوف يبقى المشاهدون على القائمة الخاطئة حتى تنتهي مدتها في كل نقاط ال CDN.
  • مشاركة الموارد بين النطاقات CORS: إذا كانت الصفحة على app.example.com والأجزاء على cdn.example.com، فيجب أن يرد ال CDN بالترويسة Access-Control-Allow-Origin، لأن hls.js وdash.js يحملان الأجزاء بطلبات JavaScript وليس بعنصر الفيديو مباشرة، بينما مشغل Safari الأصلي لا يحتاجها، فيعمل البث في iPhone ويفشل في Chrome.
  • أسماء الملفات: لا تعد استخدام نفس اسم المجلد لنسخة جديدة من نفس الفيديو، فالأجزاء مخزنة سنة كاملة في ال CDN، وإذا أعدت التحويل بسلم مختلف وبنفس الأسماء فقد يحصل المشاهد على جزء من الحزمة القديمة وجزء من الجديدة. ضع رقماً للنسخة في المسار، مثل /v/lecture-17/r2/master.m3u8.

وهذا إعداد nginx الذي يطبق القواعد السابقة على مجلد الحزم:

server {
    listen 80;
    root /usr/share/nginx/html;
    types {
        text/html html;
        text/javascript js;
        application/vnd.apple.mpegurl m3u8;
        application/dash+xml mpd;
        video/iso.segment m4s;
    }
    location ~ \.(m3u8|mpd)$ { add_header Cache-Control "no-cache"; }
    location ~ \.m4s$ { add_header Cache-Control "public, max-age=31536000, immutable"; }
}

وقد شرحنا تخزين الأجزاء في تخزين الكائنات ووضع نقطة Cache أمامه في منصة فيديو مثل Netflix، فلن نكرره هنا.

التكلفة Cost: التخزين والنقل

البث المتكيف يضاعف التخزين ولكنه يخفض النقل، وهذا تبادل يجب أن تحسبه قبل أن تختار عدد الدرجات. ومن أرقام التجربة: دقيقتان من الفيديو بالسلم كاملاً حجمها 145 ميجابايت، أي قرابة 72.6 ميجابايت للدقيقة، منها 36.8 ميجابايت لنسخة 1080p وحدها. فإذا رفع المدربون في المنصة عشر ساعات من المحاضرات في اليوم، فهذا قرابة 43.6 جيجابايت من الأجزاء يومياً، أو 1.3 تيرابايت شهرياً، وهو رقم يتراكم ولا يقل لأن المحاضرات لا تحذف.

أما النقل فيدفع مع كل مشاهدة، وهو في الغالب البند الأكبر: ساعة مشاهدة على نسخة 1080p من سلمنا تنقل قرابة 2.3 جيجابايت، وعلى نسخة 480p قرابة 0.6 جيجابايت. ولهذا فالسلم الجيد يوفر المال من الجهتين، فالمشاهد على الهاتف لا يسحب نسخة 1080p لا تظهر تفاصيلها على شاشته، وفي hls.js يوجد خيار capLevelToPlayerSize يمنع المشغل من اختيار نسخة أكبر من حجم المشغل على الشاشة، وهو معطل افتراضياً.

وهناك تكلفة خفية رأيناها في التجربة: على اتصال سريع دون أي تقييد، حمل hls.js الفيديو كله تقريباً في الثواني الأولى، 62 جزءاً من نسخة 1080p بحجم 73.6 ميجابايت، والسبب أن حده الافتراضي للمخزن 60 ميجابايت وليس 30 ثانية فقط، فهو يحمل حتى 30 ثانية على الأقل، ويستمر ما دام المخزن أقل من 60 ميجابايت. وهذا ممتاز للمشاهد الذي يكمل المحاضرة، ولكن إذا كانت أغلب المشاهدات تنتهي في الدقيقة الأولى، كما في مقاطع المعاينة، فأنت تدفع ثمن نقل بيانات لن يشاهدها أحد. والحل أن تحدد maxMaxBufferLength وmaxBufferSize بقيم تناسب طبيعة المحتوى.

ماذا تقيس بعد الإطلاق؟ جودة التجربة QoE

المقاييس التي جمعناها في التجربة هي نفسها المقاييس التي تتابعها المنصات الكبيرة لجودة التجربة Quality of Experience، واختصاراً QoE، وكل مشغل يطلق أحداثاً تكفي لحسابها:

المقياسكيف تحسبهلماذا يهم
زمن البدء Startup Timeمن الضغط على التشغيل إلى أول حدث playingكل ثانية زائدة تزيد نسبة من يغادرون قبل أن يبدأ الفيديو
نسبة التوقف Rebuffering Ratioمجموع زمن التوقف ÷ زمن المشاهدة، من حدثي waiting وplayingأكثر ما يزعج المشاهد، وأهم من الجودة نفسها
متوسط معدل البتمعدل النسخة المعروضة موزوناً بالزمنيقيس هل السلم والمشغل يستغلان الاتصال فعلاً
عدد التبديلاتعدد مرات تغير ارتفاع الفيديوالتأرجح المستمر بين جودتين يلاحظه المشاهد
الإطارات المفقودة Dropped FramesgetVideoPlaybackQuality()جهاز لا يتحمل فك نسخة عالية حتى لو تحملها الاتصال

ويجدر الإشارة هنا إلى أن هذه المقاييس تجمع من المشغل وليس من السيرفر، فسجلات ال CDN تخبرك بما حمل وليس بما شاهده الطالب فعلاً، وقد يحمل المشغل جزءاً ثم يتخلى عنه. ولهذا تضيف المنصات كوداً صغيراً في المشغل يرسل هذه الأحداث إلى خدمة تحليلات، وهناك معيار مشترك من جمعية CTA اسمه CTA-5004 أو CMCD، أي بيانات العميل المشتركة Common Media Client Data، يجعل المشغل يرسل معلومات مثل حجم المخزن والمعدل المختار مع كل طلب جزء، فتراها في سجلات ال CDN مباشرة. وdash.js وhls.js يدعمانه كخيار.

أخطاء شائعة Common Mistakes وكيف تكتشفها

  • الثقة في BANDWIDTH الذي كتبه المجزئ: في تجربتنا كتب FFmpeg معدل الجزء الأول، أقل من الذروة الحقيقية بنسبة 40%، فتوقف hls.js. احسب القيمة من الأجزاء نفسها بعد التجزئة، أو استخدم أداة تحقق مثل mediastreamvalidator من Apple التي تقارن المعلن بالمقاس.
  • إخفاء التحذيرات بالخيار -v error: التحذير «No bit rate set for stream» كان الإشارة الوحيدة على المشكلة، فاحتفظ بسجل كامل لكل عملية تحويل حتى لو كنت تعرض الأخطاء فقط.
  • سلم بلا درجة دنيا حقيقية: إذا كانت أقل درجة تحتاج مليون بت، فكل مشاهد اتصاله 300 كيلوبت سوف يتوقف مهما كان المشغل ذكياً، ودرجة 234p بمعدل 200 كيلوبت تكلف ثلاثة ميجابايت لكل دقيقتين فقط.
  • إطارات مفتاحية عند تغير المشهد: نسيان -sc_threshold 0 يجعل الأجزاء غير متحاذية بين الدرجات، ولا يظهر الخطأ إلا عند التبديل، أي عند المشاهد صاحب الاتصال الضعيف بالضبط.
  • دقة بنسبة بكسل مختلفة: 854×480 تعطي نسبة بكسل 1280:1281، فترفض التجزئة كتابة DASH حتى تحدد -aspect أو setdar، أو تختار عرضاً مثل 852 أو 864 وتقبل اختلافاً بسيطاً في النسبة.
  • قواعد Cache معكوسة: قائمة مخزنة سنة كاملة تعني أن تصحيح BANDWIDTH لن يصل إلى المشاهدين، وأجزاء دون Cache تعني أن كل مشاهدة تذهب إلى السيرفر الأصلي.
  • ترك المخزن الافتراضي على المحتوى القصير: hls.js حمل 73.6 ميجابايت في الثواني الأولى على اتصال سريع، وهذا نقل تدفع ثمنه حتى لو أغلق المشاهد الصفحة بعد عشر ثوان.
  • تقييم البث على شبكة المكتب: كل شيء يعمل على شبكة سريعة، والمشكلات كلها ظهرت فقط عندما خفضنا السرعة، فأضف اختبار شبكة بطيئة إلى فحوصك قبل أي إطلاق، ولو بأداة Network Throttling في متصفحك.

تدريب عملي Practice

  1. أضف درجة 1440p أو درجة 540p إلى LADDER في auto.sh، وحول نفس الفيديو، ثم قارن حجم الحزمة وزمن التحويل، وشغل الحزمة على ملف شبكة mobile3 وانظر هل استخدم المشغل الدرجة الجديدة أصلاً.
  2. في صفحة المشغل فعل الخيار capLevelToPlayerSize: true في hls.js واجعل عرض الفيديو 480 بكسل، ثم اختبر على شبكة سريعة وقس كم ميجابايت وفرت.

الخلاصة Summary

  • البث المتكيف أربع قطع: سلم جودات، وأجزاء متحاذية تبدأ كلها بإطار مفتاحي في نفس اللحظة، وقوائم تصفها، ومشغل يقرر قبل كل جزء، والسيرفر لا يقدم إلا ملفات ثابتة.
  • صمم السلم بدرجات متباعدة بنسبة 1.5 إلى 2، وبسقف للمعدل Capped VBR، ولا تنس الدرجة الدنيا: في تجربتنا حولت درجة 234p بمعدل 200 كيلوبت توقفاً من 20 إلى 30 ثانية إلى توقف قصير أو لا شيء.
  • لكل معدل دقة تفوز، والدقة الأعلى ليست الأفضل دائماً عند المعدلات المنخفضة، فقس على محتواك.
  • CMAF يعني أجزاء واحدة وقائمتين، HLS وDASH، فلا تخزن الفيديو مرتين.
  • BANDWIDTH في قائمة HLS هو أعلى معدل للأجزاء وليس المتوسط، وFFmpeg كتب معدل الجزء الأول فقط عند نسخ الدفق، فتوقف hls.js في كل محاولة، ولم يتوقف مرة واحدة بعد التصحيح. احسبه من الأجزاء نفسها.
  • الأجزاء القصيرة تبدأ أسرع وتتفاعل أسرع مع تغير الشبكة: زمن البدء على 3 ميجابت كان ثلاثة أضعاف تقريباً مع أجزاء الست ثوان.
  • hls.js وdash.js يختلفان في الحذر: الأول يبدأ أعلى ويحمل حتى 60 ميجابايت مقدماً، والثاني يبدأ من أقل نسخة ويبقى أقرب إليها، واضبط أي مشغل بحسب طبيعة محتواك وتكلفة النقل.
  • الأتمتة تبدأ بمجلد مراقب وسكربت صغير ينشر الحزمة كاملة أو لا ينشرها، وعندما تكبر المنصة تنتقل إلى طابور وWorkers أو أداة مثل Tdarr.

وفي المقال التالي من نفس المرحلة إن شاء الله سوف نتحدث عن Tdarr، الأداة التي تدير التحويل لمكتبة فيديو كاملة بقواعد وواجهة ومتابعة، وهذه مقالات قريبة من الموضوع:

دليلكيف يعمل بث الفيديو المباشر وعند الطلب؟كيف يصل الفيديو إلى كل مشاهد بجودة تناسب سرعة اتصاله، ولماذا يتأخر البث المباشر عشرين ثانية أحياناً وأقل من ثانية أحياناً أخرى.دليلFFmpeg عملياً: الأداة التي تقف خلف تطبيقات الفيديوكيف يعمل FFmpeg من الداخل، وكيف تكتب أوامره للقص والدمج والترجمة العربية والصوت والصور المصغرة دون أن تفسد الملف.دليلكيف تبني منصة فيديو عند الطلب مثل Netflixكيف يتحول فيديو مرفوع إلى بث يناسب كل شاشة وسرعة اتصال، وما الذي تحتاجه منصتك من التحويل إلى التوصيل والتكلفة.دليلمفاهيم الفيديو: الحاوية والترميز Codec ومعدل البتما الذي يحدد حجم ملف الفيديو وجودته، ولماذا يعمل ملف في متصفح ولا يعمل في آخر، مع تجربة حقيقية تقيس الفرق بين الترميزات.دليلكيف تبني تطبيق بث مباشر مثل Jaco وTwitchكيف يصل بث المذيع إلى آلاف المشاهدين بتأخير ثانية أو ثانيتين، ومعه دردشة وهدايا لا تتوقف عند الذروة.دليلالطابور Queue للمبتدئين: لماذا تحتاجه وكيف يعمللماذا تضع العمل البطيء في طابور بدل أن ينتظره المستخدم، وكيف تضمن ألا تضيع الرسالة إذا توقف ال Worker فجأة.

سجل التحديثات Changelog

  • أكتوبر 2026: كتابة المقال، وتنفيذ التجربة على FFmpeg 8.1.2 من حزمة Alpine مع libx264 داخل ال Docker Image bluenviron/mediamtx:1.21.1-ffmpeg، ومشغلي hls.js 1.7.3 وdash.js 5.2.1 في Chrome دون واجهة، على دقيقتين من فيلم Big Buck Bunny.
نشرة عرب رووت | ArabRoot

معرفة تستحق مكاناً في بريدك.

مقالات مختارة وأدوات مفيدة وأفكار لمشروعك القادم، في رسالة واحدة كل أسبوع.

يمكنك إلغاء الاشتراك متى شئت. الخصوصية

تم استلام طلبك. افتح بريدك واضغط رابط التأكيد لإتمام الاشتراك.