DDevelopment & Design

RTMP – Real Time Messaging Protocol

  • byTouK
  • August 11, 2008
  • 3 minute read

Protokół RTMP jest to zamknięty standard przemysłowy stworzony przez Adobe System. Jest używany do przesyłania obiektów AMF  (Action Message Format) oraz danych w formie strumieniowej takich jaki audio i wideo pomiedzy klientem i serwerem Flash. RTMP do transportu wykorzustuje bezpośrednio protokół TCP/IP na porcie 1935 tunel HTTP na porcie 80 (RTMPT). Możliwe jest przesyłanie do 64 strumieni jednocześnie po tym samym połaczeniu. W kazdym pakiecie AMF znajduje sie numer identyfikujący strumien. Dana pakiet RTMP może zawierać wiele wiadmości AMF.

Pakiet RTMP

Pakiet rtmp składa się z nagłówka o stałej długości oraz o zmiennej długości zawartości. Długość nagłówka może przyjmować cztery wartości:

  • 00 – 12 bajtów
  • 01 – 8 bajtów
  • 10 – 4 bajty
  • 11 – 1 bajt

Krótsza długość nagłówka oznacza ze brakujace dane są takie same jak te wysłane w ostatnim pakiecie je zawierającym z tym samym object id.

Pierwszy bajt zawiera informacje o długości nagłówka oraz id obiektu. Długość nagłówka zawarta jest w pierwszych dwóch bitach a id obiektu w kolejnych 6. Id obiektu wskazuje na id wiadomości AMF powiązaną z danym strumieniem danych. Oznacza to ze możliwe jest przesłanie 64 typów obiektów czyli obsłużenie 64 strumieni w tym samym połaczeniu.

Kolejne trzy bajty zawierają timestamp, przesyłany zawsze gdy długość nagłówka jest wieksza/równa 4 bajty. Jego zastosowanie i znaczenie nie jest znane:)

Kolejne trzy bajty zawierają wielkość zawartości pakietu RTMP (bez nagłówka), domyślnie dla danych video oraz audio jest to 128 i 64 bajty. Natępujący bajt zawiera typ przkazywanego obiektu AMF.:

  • 0x03 (Bytes Read) – wysyłany co x odebranych bajtów przez obie strony
  • 0x04 (Ping) – używany do kontroli stanu strumienia, dzieli się na podtypy
  • 0x05 (Server) – odpowiedzi serwera
  • 0x06 (Client) – zapytania klienta
  • 0x08 (Audio Data) – dane audio
  • 0x09 (Video Data) – dane video
  • 0x12 (Notify) – wywołanie nie oczekujące na odpowiedź
  • 0x13 (Shared Object) – obiekt współdzielony, dzieli sie na podtypy
  • 0x14 (Invoke) – wywołanie metody RPC na obiekcie zdalnym

Ostatnie cztery bajty zawierają id strumienia. Jeśli nadawca pakietu jest klient to zawierają one obiekt źródłowy ‘NetStream’, natomiast jeśli nadawcą jest serwer to zawierają obiekt ‘NetStream’ przypisany do tego strumienia po stronie serwera.

Połaczenie (Handshake)

Każde połaczenie inicjowane jest przez klienta. Inicjalizacja ma miejsce w oparciu o tzw ‘handshake’. Klient wysyła do serwera pojedyńczy bajt o wartości 0x03 i tablicę bajtów o długości 1536 oraz zapamiętuje zawartość tablicy. Serwer w odpowiedzi wysyła pojedyńczy bajt o wartośći 0x03 oraz dwie tablice bajtów o długości 1536.  Zawartość drugiej tablicy jest kopią pierwszej tablicy wysłanej przez klienta. Klient porównuje zawartości tablicy i jeśli są zgodne wysyła do serwera ostateczne potwierdzenie w postaci pojedyńczego bajtu i tablicy bajtów o długości 1536 bedącej kopią pierwszej tablicy otrzymanej w odpowiedzi od serwera. Od tej pory połaczenie jest nawiązane.

Obiekty AMF

Po nawiązaniu połaczenia dane audio jak i video są przesyłane w obiektach używających struktury AMF. Format AMF jest wykorzystywany do przenoszenia klas LocalConnection, SharedObject, NetConnection, and NetStream. Wszystkie obiekty AMF są poprzedzone jedno bajtowym nagłówkiem lub nagłówkiem zgodnym z opakowującym nagłówkiem RTMP. Pierwsze bajt wskazuje na typ obiektu, zanczenie kolejnych bajtów zależy bezpośrednio od typu obiektu:

  • 0x00 – 8 bajtów, liczba
  • 0x01 – 1 bajt, wartość boolean
  • 0x02 – string
  • 0x03 – obiekt, jest to lista par typu klucz/wartość. Klucz jest reprezentowany jako String a wartość to obiekt AMF. Koniec obiektu jest wskazany za pomocą 0x000009 (parę o zerowej długości kluczu i wartości końca obiektu)
  • 0x04 – film flash
  • 0x05 – 0 bajtów, wartość NULL
  • 0x06 – 0 bajtów, wartość niezdefioniowana
  • 0x07 – referencja
  • 0x08 – tablica ECMA
  • 0x09 – 0 bajtów, koniec obiektu
  • 0x0a – stala tablica
  • 0x0b – data
  • 0x0c – string wielobajtowy
  • 0x0d – typ niewspierany
  • 0x0e – zbiór rekordów
  • 0x0f – obiekt XML
  • 0x10 – obiekt typowany

— Previous article

SIP & SDP - Session Description Protocol

Next article —

Subtelny feature konstrukcji CONNECT BY

You May Also Like
DDevelopment & Design

Inconsistent Dependency Injection to domains with Grails

I've encountered strange behavior with a domain class in my project: services that should be injected were null. I've became suspicious as why is that? Services are injected properly in other domain classes so why this one is different?

Constructors experiment

I've created an experiment. I've created empty LibraryService that should be injected and Book domain class like this:

class Book {
    def libraryService

    String author
    String title
    int pageCount

    Book() {
        println("Finished constructor Book()")
    }

    Book(String author) {
        this()
        this.@author = author
        println("Finished constructor Book(String author)")
    }

    Book(String author, String title) {
        super()
        this.@author = author
        this.@title = title
        println("Finished constructor Book(String author, String title)")
    }

    Book(String author, String title, int pageCount) {
        this.@author = author
        this.@title = title
        this.@pageCount = pageCount
        println("Finished constructor Book(String author, String title, int pageCount)")
    }

    void logInjectedService() {
        println("    Service libraryService is injected? -> $libraryService")
    }
}
class LibraryService {
    def serviceMethod() {
    }
}

Book has 4 explicit constructors. I want to check which constructor is injecting dependecies. This is my method that constructs Book objects and I called it in controller: 

class BookController {
    def index() {
        constructAndExamineBooks()
    }

    static constructAndExamineBooks() {
        println("Started constructAndExamineBooks")
        Book book1 = new Book().logInjectedService()
        Book book2 = new Book("foo").logInjectedService()
        Book book3 = new Book("foo", 'bar').logInjectedService()
        Book book4 = new Book("foo", 'bar', 100).logInjectedService()
        Book book5 = new Book(author: "foo", title: 'bar')
        println("Finished constructor Book(Map params)")
        book5.logInjectedService()
    }
}

Analysis

Output looks like this:

Started constructAndExamineBooks
Finished constructor Book()
    Service libraryService is injected? -> eu.spoonman.refaktor.LibraryService@2affcce2
Finished constructor Book()
Finished constructor Book(String author)
    Service libraryService is injected? -> eu.spoonman.refaktor.LibraryService@2affcce2
Finished constructor Book(String author, String title)
    Service libraryService is injected? -> null
Finished constructor Book(String author, String title, int pageCount)
    Service libraryService is injected? -> null
Finished constructor Book()
Finished constructor Book(Map params)
    Service libraryService is injected? -> eu.spoonman.refaktor.LibraryService@2affcce2

What do we see?

  1. ✔

    Empty constructor injects dependencies.

  2. ✔

    Constructor that invokes empty constructor explicitly injects dependencies.

  3. ✘

    Constructor that invokes parent's constructor explicitly does not inject dependencies.

  4. ✘

    Constructor without any explicit call declared does not call empty constructor thus it does not inject dependencies.

  5. ✔

    Constructor provied by Grails with a map as a parameter invokes empty constructor and injects dependencies.

Conclusion

Always explicitily invoke empty constructor in your Grail domain classes to ensure Dependency Injection! I didn't know until today either!