דף זה תורגם על ידי Cloud Translation API.

מה זה EME?

Sam Dutton

תוספי מדיה מוצפנים מספקים ממשק API שמאפשר לאפליקציות אינטרנט לקיים אינטראקציה עם מערכות להגנה על תוכן, וכך לאפשר הפעלה של אודיו ווידאו מוצפנים.

EME נועד לאפשר שימוש באותה אפליקציה ובקבצים מוצפנים בכל דפדפן, ללא קשר למערכת ההגנה הבסיסית. האפשרות הראשונה מתאפשרת באמצעות ממשקי ה-API והתהליך הסטנדרטיים, והאפשרות השנייה מתאפשרת באמצעות המושג הצפנה משותפת.

EME הוא תוסף למפרט HTMLMediaElement – ומכאן השם. העובדה ש-EME הוא 'תוסף' מאפשרת לדפדפנים לבחור אם לתמוך בו: אם דפדפן לא תומך במדיה מוצפנת, לא ניתן יהיה להפעיל בו מדיה מוצפנת, אבל EME לא נדרש כדי לעמוד בדרישות של מפרט HTML. ממפרט ה-EME:

ההצעה הזו מרחיבה את HTMLMediaElement ומספקת ממשקי API לצורך בקרה על ההפעלה של תוכן מוגן.

ה-API תומך בתרחישי שימוש שונים, החל מפענוח מפתחות פשוט ועד וידאו בעל ערך גבוה (בהתאם להטמעה המתאימה של סוכן משתמש). החלפת הרישיון או המפתח מבוקרת על ידי האפליקציה, וכך קל יותר לפתח אפליקציות הפעלה חזקות שתומכות במגוון טכנולוגיות של הצפנה והגנה על תוכן.

המפרט הזה לא מגדיר הגנה על תוכן או מערכת לניהול זכויות דיגיטליות. במקום זאת, הוא מגדיר ממשק API משותף שאפשר להשתמש בו כדי לגלות מערכות כאלה, לבחור אותן ולנהל איתן אינטראקציה, וגם מערכות פשוטות יותר להצפנת תוכן. כדי לעמוד בדרישות המפרט הזה, לא נדרשת הטמעה של ניהול זכויות דיגיטלי (DRM): צריך להטמיע רק את מערכת Clear Key כבסיס משותף.

ה-API המשותף תומך ביכולות פשוטות של הצפנת תוכן, ומאפשר לכותבי הדפים להשתמש בפונקציות של האפליקציה כמו אימות והרשאה. כדי לעשות זאת, נדרש שהדף יתן חסות להעברת הודעות ספציפיות למערכת להגנה על תוכן, במקום להניח שקיימת תקשורת מחוץ למסגרת בין מערכת ההצפנה לבין רישיון או שרת אחר.

הטמעות של EME משתמשות ברכיבים החיצוניים הבאים:

מערכת מפתחות: מנגנון להגנה על תוכן (DRM). EME לא מגדיר מערכות מפתחות בעצמו, מלבד Clear Key (מידע נוסף מופיע בהמשך).
מודול לפענוח תוכן (CDM): מנגנון תוכנה או חומרה בצד הלקוח שמאפשר הפעלה של מדיה מוצפנת. כמו ב-Key Systems, EME לא מגדיר את מפתחות ה-CDM, אלא מספק ממשק לאפליקציות לאינטראקציה עם פקודות CDM זמינות.
שרת רישיונות (מפתחות): מתקשר עם CDM כדי לספק מפתחות לפענוח מדיה. המשא ומתן עם שרת הרישיונות הוא באחריות האפליקציה.
שירות אריזה: קידוד והצפנה של מדיה לצורך הפצה או שימוש.

הערה: אפליקציה שמשתמשת ב-EME מקיימת אינטראקציה עם שרת רישיונות כדי לקבל מפתחות לצורך פענוח, אבל זהות המשתמש והאימות שלו אינם חלק מ-EME. אחזור המפתחות להפעלת מדיה מתבצע אחרי אימות המשתמש (אופציונלי). שירותים כמו Netflix חייבים לאמת משתמשים באפליקציית האינטרנט שלהם: כשמשתמש נכנס לאפליקציה, האפליקציה קובעת את הזהות וההרשאות של המשתמש.

איך פועל EME?

כך הרכיבים של EME מקיימים אינטראקציה, בהתאם לדוגמה לקוד בהמשך:

אם יש כמה פורמטים או קודיקים זמינים, אפשר להשתמש ב-MediaSource.isTypeSupported() או ב-HTMLMediaElement.canPlayType() כדי לבחור את הפורמט או הקודק המתאים. עם זאת, יכול להיות שה-CDM יתמוך רק בקבוצת משנה של התכונות שתומך בהן הדפדפן לתוכן לא מוצפן. מומלץ לנהל משא ומתן על הגדרת MediaKeys לפני שבוחרים פורמט וקודק. אם האפליקציה ממתינה לאירוע המוצפן, אבל לאחר מכן MediaKeys מציגה שהיא לא יכולה לטפל בפורמט או בקודק שנבחרו, יכול להיות שיהיה מאוחר מדי לעבור לפורמט אחר בלי להפריע להפעלה.

התהליך המומלץ הוא לנהל משא ומתן על MediaKeys קודם, ולהשתמש ב-MediaKeysSystemAccess.getConfiguration() כדי לברר מהי ההגדרה המוסכמת.

אם יש רק פורמט/קודק אחד לבחירה, אין צורך ב-getConfiguration(). עם זאת, עדיין עדיף להגדיר קודם את MediaKeys. הסיבה היחידה להמתנה לאירוע המוצפן היא אם אין דרך לדעת אם התוכן מוצפן או לא, אבל בפועל זה לא סביר.

אפליקציית אינטרנט מנסה להפעיל אודיו או וידאו עם שידור מוצפן אחד או יותר.
הדפדפן מזהה שהמדיה מוצפנת (בקטע הבא מוסבר איך זה קורה) ומפעיל אירוע מוצפן עם מטא-נתונים (initData) שהתקבלו מהמדיה לגבי ההצפנה.
האפליקציה מטפלת באירוע המוצפן:
1. אם לא משויך לאובייקט המדיה אובייקט MediaKeys, קודם צריך לבחור מערכת מפתחות זמינה באמצעות navigator.requestMediaKeySystemAccess() כדי לבדוק אילו מערכות מפתחות זמינות, ואז ליצור אובייקט MediaKeys למערכת מפתחות זמינה באמצעות אובייקט MediaKeySystemAccess. חשוב לזכור שהפעלת האובייקט MediaKeys צריכה להתרחש לפני האירוע המוצפן הראשון. קבלת כתובת ה-URL של שרת הרישיונות מתבצעת על ידי האפליקציה בלי לבחור מערכת מפתחות זמינה. אובייקט MediaKeys מייצג את כל המפתחות שזמינים לפענוח המדיה של רכיב אודיו או וידאו. הוא מייצג מכונה של CDM ומספק גישה ל-CDM, במיוחד ליצירת סשנים של מפתחות, המשמשים לקבלת מפתחות משרת רישיונות.
2. אחרי שיוצרים את האובייקט MediaKeys, מקצים אותו לרכיב המדיה: הפונקציה setMediaKeys() משייכת את האובייקט MediaKeys ל-HTMLMediaElement, כדי שאפשר יהיה להשתמש במפתחות שלו במהלך ההפעלה, כלומר במהלך פענוח הנתונים.
האפליקציה יוצרת MediaKeySession באמצעות קריאה ל-createSession() ב-MediaKeys. הפעולה הזו יוצרת MediaKeySession, שמייצג את משך החיים של רישיון ואת המפתחות שלו.
האפליקציה יוצרת בקשת רישיון על ידי העברת נתוני המדיה שהתקבלו במנהל האירועים המוצפן ל-CDM, באמצעות קריאה ל-generateRequest()‏ ב-MediaKeySession.
ה-CDM יוצר אירוע הודעה: בקשה לקבלת מפתח משרת רישיונות.
האובייקט MediaKeySession מקבל את אירוע ההודעה והאפליקציה שולחת הודעה לשרת הרישיונות (לדוגמה, באמצעות XHR).
האפליקציה מקבלת תשובה משרת הרישיונות ומעבירה את הנתונים ל-CDM באמצעות השיטה update()‎ של MediaKeySession.
ה-CDM מפענח את המדיה באמצעות המפתחות ברישיון. אפשר להשתמש במפתח תקין מכל סשן ב-MediaKeys שמשויך לרכיב המדיה. ה-CDM ייגש למפתח ולמדיניות, וייוצרו להם אינדקסים לפי מזהה המפתח.

הפעלת המדיה תמשיך.

איך הדפדפן מזהה שהמדיה מוצפנת?

המידע הזה נמצא במטא-נתונים של קובץ מאגר המדיה, שיהיה בפורמט כמו ISO BMFF או WebM. ב-ISO BMFF, המטא-נתונים של הכותרת נקראים 'תיבת המידע של סכמת ההגנה'. קובצי WebM משתמשים ברכיב Matroska ContentEncryption, עם כמה תוספות ספציפיות ל-WebM. ההנחיות לכל מאגר זמינות במרשם ספציפי ל-EME.

שימו לב: יכולות להיות כמה הודעות בין ה-CDM לבין שרת הרישיונות, וכל התקשורת בתהליך הזה היא אטומה לדפדפן ולאפליקציה: רק ה-CDM ושרת הרישיונות יכולים להבין את ההודעות, אבל שכבת האפליקציה יכולה לראות איזה סוג הודעה ה-CDM שולח. בקשת הרישיון מכילה הוכחה לתקינות של CDM (וליחסי האמון שלו), וגם מפתח לשימוש בהצפנת מפתחות התוכן ברישיון שנוצר.

אבל מה בעצם ה-CDM עושים?

הטמעת EME לא מספקת בעצמה דרך לפענח מדיה: היא פשוט מספקת ממשק API לאפליקציית אינטרנט כדי ליצור אינטראקציה עם מודולים לפענוח תוכן.

הפעילות בפועל של CDM לא מוגדרת במפרט EME, ו-CDM יכול לטפל גם בפענוחי (דחיסה) מדיה וגם בפענוח. יש כמה אפשרויות פוטנציאליות לפונקציונליות של CDM, מהאפשרות החלשה ביותר ועד לאפשרות החזקה ביותר:

פענוח בלבד, שמאפשר הפעלה באמצעות צינור עיבוד הנתונים הרגיל של המדיה, למשל באמצעות רכיב <video>.
פענוח ופענוח, העברת פריטי וידאו לדפדפן לצורך עיבוד.
פענוח ופענוח, עיבוד ישירות בחומרה (לדוגמה, ה-GPU).

יש כמה דרכים להפוך מאגר נתונים מנוהל (CDM) לזמין לאפליקציית אינטרנט:

מצרפים CDM לדפדפן.
הפצת CDM בנפרד.
פיתוח CDM במערכת ההפעלה.
הוספת CDM לקושחה.
הטמעת CDM בחומרה.

האופן שבו CDM זמין לא מוגדר במפרט EME, אבל בכל המקרים הדפדפן אחראי על בדיקת ה-CDM ועל חשיפת ה-CDM.

EME לא מחייב שימוש במערכת מפתחות מסוימת. בדפדפנים הנוכחיים למחשב ולנייד, Chrome תומך ב-Widevine ו-IE11 תומך ב-PlayReady.

אחזור מפתח משרת רישיונות

בשימוש מסחרי רגיל, התוכן יוצפן ומקודד באמצעות שירות או כלי אריזה. אחרי שהמדיה המוצפנת זמינה באינטרנט, לקוח אינטרנט יכול לקבל מפתח (שכולל ברישיון) משרת רישיונות ולהשתמש במפתח כדי לפענח ולהפעיל את התוכן.

הקוד הבא (בהתאמה מתוך הדוגמאות למפרטים) מראה איך אפליקציה יכולה לבחור מערכת מפתחות מתאימה ולקבל מפתח משרת רישיונות.

    var video = document.querySelector('video');

    var config = [{initDataTypes: ['webm'],
      videoCapabilities: [{contentType: 'video/webm; codecs="vp09.00.10.08"'}]}];

    if (!video.mediaKeys) {
      navigator.requestMediaKeySystemAccess('org.w3.clearkey',
          config).then(
        function(keySystemAccess) {
          var promise = keySystemAccess.createMediaKeys();
          promise.catch(
            console.error.bind(console, 'Unable to create MediaKeys')
          );
          promise.then(
            function(createdMediaKeys) {
              return video.setMediaKeys(createdMediaKeys);
            }
          ).catch(
            console.error.bind(console, 'Unable to set MediaKeys')
          );
          promise.then(
            function(createdMediaKeys) {
              var initData = new Uint8Array([...]);
              var keySession = createdMediaKeys.createSession();
              keySession.addEventListener('message', handleMessage,
                  false);
              return keySession.generateRequest('webm', initData);
            }
          ).catch(
            console.error.bind(console,
              'Unable to create or initialize key session')
          );
        }
      );
    }

    function handleMessage(event) {
      var keySession = event.target;
      var license = new Uint8Array([...]);
      keySession.update(license).catch(
        console.error.bind(console, 'update() failed')
      );
    }

הצפנה נפוצה

פתרונות של הצפנה משותפת מאפשרים לספקים של תוכן להצפין את התוכן שלהם ולארז אותו פעם אחת לכל מאגר/קודק, ולהשתמש בו עם מגוון מערכות מפתחות, פלטפורמות CDM ולקוחות: כלומר, כל פלטפורמת CDM שתומכת בהצפנה משותפת. לדוגמה, אפשר להפעיל סרטון שארוז באמצעות PlayReady בדפדפן באמצעות CDM של Widevine שמקבל מפתח משרת רישיונות של Widevine.

בניגוד לפתרונות מדור קודם שפועלים רק עם סטאק אנכי מלא, כולל לקוח יחיד שלרוב כולל גם סביבת זמן ריצה של אפליקציה.

הצפנה משותפת (CENC) היא תקן ISO שמגדיר סכימה להגנה על ISO BMFF. רעיון דומה חל על WebM.

מקש ניקוי

למרות ש-EME לא מגדיר פונקציונליות של DRM, המפרט כרגע קובע כי כל הדפדפנים שתומכים ב-EME חייבים להטמיע מפתח ניקוי. באמצעות המערכת הזו, אפשר להצפין את המדיה באמצעות מפתח ואז להפעיל את המדיה רק על ידי מתן המפתח הזה. אפשר להטמיע את Clear Key בדפדפן: הוא לא מחייב שימוש במודול פענוח נפרד.

לא סביר להניח שישמשו לסוגים רבים של תוכן מסחרי, אבל אפשר להשתמש ב-clear Key, בכל הדפדפנים שתומכים ב-EME. הוא גם שימושי לבדיקת הטמעות של EME ואפליקציות שמשתמשות ב-EME, בלי צורך לבקש מפתח תוכן משרת רישיונות. בכתובת simpl.info/ck יש דוגמה פשוטה של מפתח שקוף. בהמשך מופיע הסבר על הקוד, שתואם לשלבים שמפורטים למעלה, אבל בלי אינטראקציה עם שרת הרישיונות.

// Define a key: hardcoded in this example
// – this corresponds to the key used for encryption
var KEY = new Uint8Array([
  0xeb, 0xdd, 0x62, 0xf1, 0x68, 0x14, 0xd2, 0x7b, 0x68, 0xef, 0x12, 0x2a, 0xfc,
  0xe4, 0xae, 0x3c,
]);

var config = [
  {
    initDataTypes: ['webm'],
    videoCapabilities: [
      {
        contentType: 'video/webm; codecs="vp8"',
      },
    ],
  },
];

var video = document.querySelector('video');
video.addEventListener('encrypted', handleEncrypted, false);

navigator
  .requestMediaKeySystemAccess('org.w3.clearkey', config)
  .then(function (keySystemAccess) {
    return keySystemAccess.createMediaKeys();
  })
  .then(function (createdMediaKeys) {
    return video.setMediaKeys(createdMediaKeys);
  })
  .catch(function (error) {
    console.error('Failed to set up MediaKeys', error);
  });

function handleEncrypted(event) {
  var session = video.mediaKeys.createSession();
  session.addEventListener('message', handleMessage, false);
  session
    .generateRequest(event.initDataType, event.initData)
    .catch(function (error) {
      console.error('Failed to generate a license request', error);
    });
}

function handleMessage(event) {
  // If you had a license server, you would make an asynchronous XMLHttpRequest
  // with event.message as the body.  The response from the server, as a
  // Uint8Array, would then be passed to session.update().
  // Instead, we will generate the license synchronously on the client, using
  // the hard-coded KEY at the top.
  var license = generateLicense(event.message);

  var session = event.target;
  session.update(license).catch(function (error) {
    console.error('Failed to update the session', error);
  });
}

// Convert Uint8Array into base64 using base64url alphabet, without padding.
function toBase64(u8arr) {
  return btoa(String.fromCharCode.apply(null, u8arr))
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=*$/, '');
}

// This takes the place of a license server.
// kids is an array of base64-encoded key IDs
// keys is an array of base64-encoded keys
function generateLicense(message) {
  // Parse the clearkey license request.
  var request = JSON.parse(new TextDecoder().decode(message));
  // We only know one key, so there should only be one key ID.
  // A real license server could easily serve multiple keys.
  console.assert(request.kids.length === 1);

  var keyObj = {
    kty: 'oct',
    alg: 'A128KW',
    kid: request.kids[0],
    k: toBase64(KEY),
  };
  return new TextEncoder().encode(
    JSON.stringify({
      keys: [keyObj],
    }),
  );
}

כדי לבדוק את הקוד הזה, צריך להפעיל סרטון מוצפן. אפשר להצפין סרטון לשימוש עם Clear Key בפורמט WebM לפי ההוראות של webm_crypt. יש גם שירותים מסחריים (בתקן ISO BMFF/MP4 לפחות), ואנחנו מפתחים פתרונות אחרים.

טכנולוגיה קשורה 1: Media Source Extensions‏ (MSE)

HTMLMediaElement הוא יצור פשוט ויפה.

אנחנו יכולים לטעון, לפענח ולהפעיל מדיה פשוט על ידי מתן כתובת URL של src:

<video src="foo.webm"></video>

ממשק ה-API של Media Source הוא תוסף ל-HTMLMediaElement שמאפשר שליטה פרטנית יותר במקור המדיה, בכך שהוא מאפשר ל-JavaScript ליצור סטרימינג להפעלה מ'מקטעים' של סרטונים. כך מתאפשרת שיטות כמו סטרימינג אדפטיבי והזזת זמן.

למה MSE חשוב ל-EME? הסיבה לכך היא שבנוסף להפצת תוכן מוגן, ספקי תוכן מסחרי צריכים להיות מסוגלים להתאים את העברת התוכן לתנאי הרשת ולדרישות אחרות. לדוגמה, Netflix משנה באופן דינמי את קצב הנתונים של הסטרימינג בהתאם לשינויים בתנאי הרשת. EME פועל עם הפעלה של שידורי מדיה שסופקו על ידי הטמעת MSE, בדיוק כמו שהוא פועל עם מדיה שסופקה באמצעות מאפיין src.

איך מחלקים קטעי מדיה עם קצב העברת נתונים שונה לקטעים ומפעילים אותם? בקטע DASH בהמשך.

אפשר לראות את MSE בפעולה בכתובת simpl.info/mse. לצורך הדוגמה הזו, סרטון WebM מחולק לחמישה קטעים באמצעות ממשקי ה-API של קבצים. באפליקציה בסביבת ייצור, קטעי וידאו יאוחזרו באמצעות AJAX.

קודם נוצר SourceBuffer:

var sourceBuffer = mediaSource.addSourceBuffer(
  'video/webm; codecs="vorbis,vp8"',
);

לאחר מכן, הסרט כולו 'מוזרם' אל רכיב הווידאו על ידי צירוף כל מקטע באמצעות השיטה appendBuffer():

reader.onload = function (e) {
  sourceBuffer.appendBuffer(new Uint8Array(e.target.result));
  if (i === NUM_CHUNKS - 1) {
    mediaSource.endOfStream();
  } else {
    if (video.paused) {
      // start playing after first chunk is appended
      video.play();
    }
    readChunk_(++i);
  }
};

מידע נוסף על MSE זמין במאמר מידע בסיסי על MSE.

טכנולוגיה קשורה 2: שידור דינמי שניתן להתאמה באמצעות HTTP‏ (DASH)

מכשירים מרובים, פלטפורמות מרובות, ניידים – לא משנה איך אתם קוראים לזה, לרוב הגולשים נתקלים באינטרנט בתנאים של קישוריות משתנה. הצגה דינמית וגמישה היא הכרחית להתמודדות עם מגבלות רוחב פס והשונות בעולם מרובה מכשירים.

DASH (נקרא גם MPEG-DASH) נועד לספק את העברת המדיה הטובה ביותר שאפשר בעולם לא יציב, גם בסטרימינג וגם בהורדה. יש כמה טכנולוגיות אחרות שעושות משהו דומה, כמו HTTP Live Streaming (HLS) של Apple ו-Smooth Streaming – אבל DASH הוא השיטה היחידה לסטרימינג בקצב העברת נתונים דינמי באמצעות HTTP המבוסס על תקן פתוח. אתרים כמו YouTube כבר משתמשים ב-DASH.

מה הקשר ל-EME ול-MSE? הטמעות DASH שמבוססות על MSE יכולות לנתח מניפסט, להוריד קטעי וידאו בקצב נתונים מתאים ולהעביר אותם לרכיב וידאו כשהוא זקוק לנתונים – באמצעות תשתית HTTP קיימת.

כלומר, DASH מאפשר לספקי תוכן מסחרי לבצע סטרימינג דינמי של תוכן מוגן.

ה-DASH עושה את מה שהוא מציע:

דינמית: מגיבה לשינויים בתנאים.
דינמי: הסרטון מותאם כדי לספק קצב דגימה מתאים של אודיו או וידאו.
סטרימינג: מאפשר סטרימינג וגם הורדה.
HTTP: מאפשר העברת תוכן עם היתרונות של HTTP, בלי החסרונות של שרת סטרימינג רגיל.

ה-BBC התחיל לספק שידורי בדיקה באמצעות DASH:

המדיה מקודדת כמה פעמים בקצב העברת נתונים שונה. כל קידוד נקרא ייצוג. הם מחולקים למספר פלחי מדיה. הלקוח מפעיל תוכנית על ידי שליחת בקשות לקטעים, לפי הסדר, מהייצוג ב-HTTP. אפשר לקבץ ייצוגים לקבוצות של ייצוגים שמכילים תוכן שווה ערך. אם הלקוח רוצה לשנות את קצב הנתונים, הוא יכול לבחור חלופה מתוך קבוצת ההתאמה הנוכחית ולהתחיל לבקש פלחים מהייצוג הזה. התוכן מקודד בצורה שמאפשרת ללקוח לבצע את המעבר בקלות, בנוסף למספר פלחי מדיה, לייצוג יש בדרך כלל גם פלח אתחול. אפשר לחשוב עליו ככותרת שמכילה מידע על הקידוד, על גדלי המסגרות וכו'. הלקוח צריך לקבל את המידע הזה לגבי ייצוג נתון לפני שהוא צורך קטעי מדיה מהייצוג הזה.

לסיכום:

המדיה מקודדת בקצב העברת נתונים שונה.
קבצים עם שיעורי ביט שונים זמינים משרת HTTP.
אפליקציית אינטרנט של לקוח בוחרת את קצב העברת הנתונים לאחזר ולהפעיל מחדש עם DASH.

כחלק מתהליך פילוח הסרטון, נוצר באופן פרוגרמטי מניפסט XML שנקרא תיאור של הצגת מדיה (MPD). כאן מתוארים קבוצות של עיבודים וייצוגים, עם משכי זמן וכתובות URL. קובץ MPD נראה כך:

    <MPD xmlns="urn:mpeg:DASH:schema:MPD:2011" mediaPresentationDuration="PT0H3M1.63S" minBufferTime="PT1.5S" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011"
    type="static">
      <Period duration="PT0H3M1.63S" start="PT0S">
        <AdaptationSet>
          <ContentComponent contentType="video" id="1" />
          <Representation bandwidth="4190760" codecs="avc1.640028" height="1080" id="1" mimeType="video/mp4" width="1920">
            <BaseURL>car-20120827-89.mp4</BaseURL>
            <SegmentBase indexRange="674-1149">
              <Initialization range="0-673" />
            </SegmentBase>
          </Representation>
          <Representation bandwidth="2073921" codecs="avc1.4d401f" height="720" id="2" mimeType="video/mp4" width="1280">
            <BaseURL>car-20120827-88.mp4</BaseURL>
            <SegmentBase indexRange="708-1183">
              <Initialization range="0-707" />
            </SegmentBase>
          </Representation>

          …

        </AdaptationSet>
      </Period>
    </MPD>

(קובץ ה-XML הזה נלקח מקובץ ה-‎ .mpd שמשמש את נגן הדגמה של YouTube DASH).

לפי מפרט DASH, בתיאוריה ניתן להשתמש בקובץ MPD כסימן ה-src של סרטון. עם זאת, כדי לתת גמישות רבה יותר למפתחי אינטרנט, יצרני הדפדפנים בחרו להשאיר את התמיכה ב-DASH לספריות JavaScript שמשתמשות ב-MSE, כמו dash.js. הטמעת DASH ב-JavaScript מאפשרת לאלגוריתם ההתאמה להתפתח בלי צורך בעדכוני דפדפן. השימוש ב-MSE מאפשר גם להתנסות בפורמטים חלופיים של מניפסט ובמנגנוני העברה בלי צורך בשינויים בדפדפן. Shaka Player של Google מטמיע לקוח DASH עם תמיכה ב-EME.

ב-Mozilla Developer Network יש הוראות כיצד להשתמש בכלי WebM וב-FFmpeg כדי לפלח סרטונים ולבנות MPD.

סיכום

השימוש באינטרנט להעברת סרטונים ואודיו בתשלום הולך וגדל בקצב עצום. נראה שכל מכשיר חדש, בין אם זה טאבלט, קונסולת משחקים, טלוויזיה מחוברת או ממיר, יכול להזרים מדיה מספקי התוכן העיקריים באמצעות HTTP. יותר מ-85% מהדפדפנים לנייד ולמחשב תומכים עכשיו ב-<video> וב-<audio>, חברת Cisco מעריכה שסרטונים יהוו 80 עד 90 אחוזים מתנועת הגולשים באינטרנט ברחבי העולם עד שנת 2017. בהקשר הזה, סביר להניח שתמיכת הדפדפן בהפצת תוכן מוגן תהיה משמעותית יותר ויותר, מאחר שספקי הדפדפנים מקטיזים את התמיכה בממשקי ה-API שרוב יישומי הפלאגין של המדיה מסתמכים עליהם.

קריאה נוספת

מפרטים ותקנים

מפרט EME: טיוטת העריכה האחרונה הצפנה משותפת (CENC) Media Source Extensions: טיוטת העריכה האחרונה תקן DASH (כן, זה קובץ PDF) סקירה כללית על תקן DASH

מאמרים

DTG Webinar (מיושן חלקית) What is EME?, by Henri Sivonen Media Source extensions primer MPEG-DASH Test Streams: פוסט בבלוג R&D

הדגמות

הדגמת ניקוי מפתח: simpl.info/ck הדגמה של תוספי מקור מדיה (MSE) Shaka Player של Google מיישם לקוח DASH עם תמיכה ב-EME