Running with Ruby

Tag: video (page 1 of 2)

Converting MKV video file to MP4 with hardsubs (embedded subtitles) on Linux (Ubuntu)

I had to convert some MKV video files into MP4 format with embedded (rendered) subtitles. This would not be a problem if not the external ASS subs that I had. HandBrakeCLI can easily convert between those formats but it can use embedded ASS file (from MKV video) or provided SRT. There is no way to use an external ASS subtitles file. Luckily there is a quite simple solution for that issue: we can just remove original MKV video subtitles, add ours and then use HandBrakeCLI to convert the video.

Replacing the ASS MKV subtitles with our own

First we need to remove the original ASS subtitles that are stored in MKV file:

mkvmerge --no-subtitles source.mkv -o target.mkv

This will copy MKV file but will remove subtitles.

After that, we need to add our ow ASS file (subtitles.ass):

mkvmerge -o target_with_subs.mkv target.mkv -D -A subtitles.ass

Now we have a MKV file with our ASS subtitles, that we can use to create MP4 file.

Creating MP4 file with embedded (hardcoded) subtitles

Convertion is really simple:

HandBrakeCLI -i target_with_subs.mkv -o result.mp4 -e x264 -q 20 -B 160\
 --x264-preset medium --two-pass -O --turbo --subtitle "1" \
 --subtitle-burn "1" --srt-codeset utf8

Simple one line long command and 30 minutes later you have your MP4 file with hardsubs.

Facebook i problem w JW Player – część II – cachowanie

Wstęp

Tutorial składa się z dwóch cześci:

  1. FacebookBot z wykorzystaniem Mechanize
  2. Cachowanie odpytań

Kod (nowszy i lepszy ;) ) dostępny na githubie.

Ze względu na dużą popularność wpisu dot. “naprawy” linków z Facebooka (tutaj), postanowiłem dołączyć wam drugą część poradnika. Ta część dotyczyć będzie cachowania wyników – cobyśmy za często nie odpytywali Facebooka o linki. Dlaczego lepiej jest cachować wyniki, niż każdorazowo odpytywać FB? Z dwóch powodów:

  • czas – przede wszystkim – czas potrzebny na odpytanie serwera Facebooka o potrzebne dane, a następnie zwrócenie tego klientowi, zajmuje zbyt wiele czasu. Dużo szybciej jest wyciągnąć i zwrócić pojedynczy rekord z bazy,
  • logi – Facebook na pewno nie będzie zadowolony (i nie przepuści po pewnym czasie) z tego, że codziennie nasze konto odpytuje np. 30 – 40 tys razy o strony z filmami. Uznają to za dziwne zachowanie i po prostu zbanują konto lub co gorsza IP.

Czas “życia” adresu z Facebooka to od 24 do 36 godzin. Aby ciągłość usług była stabilna, załóżmy że cache będzie działał przez 30 minut. Da nam to odpytywanie Facebooka – maksymalnie co 30 minut na filmik (a nie przy każdym żądaniu). Dodatkowo, kiedy nasz cache się przedawni, nie odpytamy od razu o nowy URL – najpierw sprawdzimy czy stary już umarł, wysyłając zapytanie o nagłówek pod URL filmu. Jeśli dostaniemy odpowiedź 200 – tzn, że link wciąż jest aktywny i nie musimy go zmieniać.

Takie podejście zapewni nam uptime na poziomie (w najgorszym przypadku): 100%-(30/1440)*100%= 97.9% czasu. A to i tak zakładając wariant, że url z FB zmieni się dokładnie po naszym odpytaniu, przez co cache będzie serwował przez całe 30 minut zły URL. Myślę, że spokojnie można przyjąć uptime na poziomie 98.5%-99%.

Ustawienia

Aby było nam łatwiej, wszystkie ustawienia będziemy przechowywać w jednym miejscu. Stwórzmy sobie plik lib/settings.rb, w którym w stałej SETTINGS będziemy przechowywać co nam trzeba:

SETTINGS = {
  :db_user    => 'user_bazy',
  :db_adapter  => "mysql",
  :db_host     => "mysql5",
  :db_database => "baza",
  :db_pass     => 'haslo',
  :db_socket   => '/tmp/mysql.sock',

  :fb_login    => 'mail@do.facebooka.pl',
  :fb_pass     => 'haslo-do-fb',
}

Baza danych

Do przechowywania danych wykorzystamy bazę MySQLa. Stworzymy sobie plik db_connector.rb, który tak jak poprzedni (i wszystkie następne oprócz main.rb) będzie przechowywany w katalogu lib/. W pliku tym będziemy trzymać kod odpowiedzialny za łączenie się z bazą danych oraz naszą “pseudo” migrację – generującą  tabelę z odpowiednimi kolumnami. Warto zwrócić uwagę na to, że mimo wykorzystania ActiveRecord – ORMa z Railsów – nie wykorzystujemy całego frameworka. Sam ORM nam w zupełności wystarczy.

ActiveRecord::Base.establish_connection(
  :adapter  => SETTINGS[:db_adapter],
  :host     => SETTINGS[:db_host],
  :database => SETTINGS[:db_database],
  :username => SETTINGS[:db_user],
  :password => SETTINGS[:db_pass],
  :socket   => SETTINGS[:db_socket]
)

unless Video.table_exists?
  ActiveRecord::Base.connection.create_table(:videos) do |t|
    t.column :video_id, :string
    t.column :name, :string
    t.column :url, :string, :default => nil
    t.column :views, :integer, :default => 1
    t.column :cached_at, :datetime
  end
end

Warto zwrócić uwagę na ten warunek:

unless Video.table_exists?

dzięki któremu migracja zostanie wykonana tylko jeśli tabela z danymi nie istnieje.

Model filmu wideo

Mamy już gdzie trzymać nasze dane. Pora stworzyć model pojedyńczego filmiku z FB. Model nasz zawierać będzie cztery metody:

  1. url=(new_url) – przypisanie nowego adresu filmiku z Facebooka,
  2. working? – metoda zwracająca true/false zależnie od tego czy filmik działa czy też nie,
  3. url_working? – metoda sprawdzająca nagłówek odpowiedzi z żądania pod adresem URL filmu,
  4. (private) set_cached_at_time – ustawiająca podczas tworzenia instancji czas cachowania na teraz.

Zacznijmy od szkieletu modelu:

require 'net/http'
require 'uri'

class Video < ActiveRecord::Base
  # 30 minut
  CACHE_TIME = 60*30

  before_create :set_cached_at_time
  # Gwarancja, ze jeden filmik bedzie mial jeden wpis w bazie
  validates_uniqueness_of :video_id
  validate :working?
end

Metody

1. url=

def url=(new_url)
  self.errors.clear
  self.cached_at = Time.now
  super new_url
end

Część z was może zapytać, dlaczego czyszczę błędy (self.errors.clear)? Czyszczę je, ponieważ przypisanie nowego URLa następuje wtedy i tylko wtedy, gdy stary był niepoprawny i nie przechodził walidacji. Nowy z założenia przechodzi, tak więc błąd starego URLa musi zostać “zapomniany”.

2. working?

def working?
  v = false
  if self.cached_at >= Time.now - CACHE_TIME && self.url.length > 10
    v = true
  else
    v = url_working?
    self.cached_at = Time.now
  end
  self.errors.add(:cached_at, 'Cache ulegl przedawnieniu') unless v
  v
end

W tej metodzie sprawdzamy czy URL jest poprawny. Jeśli jest “młody” (czyli nowszy niż 30 minut) i jego długość jest większa niż 10 (to tak dla pewności ;) ), tzn. że jest prawdziwy (w 99% procentach przypadków – patrz wstęp). W przeciwnym razie – sprawdzamy nagłówek odpowiedzi z żądania wysłanego pod link, i jeśli jest poprawny – to ok, jeśli nie – to wrzucamy błąd do tablicy błędów naszej instancji modelu. Uważniejsze osoby mogą zapytać, dlaczego ustawiamy cache na nowy – mimo, że URL się nie zmienił. Ustawiamy tak, ponieważ zmiana URLa nastąpi na pewno jeśli ten link był niepoprawny. Nastąpi ona jednak w pliku main.rb.

3. url_working?

def url_working?
  begin
    host = URI.parse(self.url).host
    http = Net::HTTP.new(host)
    headers = http.head(self.url)
  rescue
    return true
  end
  if headers.code == "200"
    true
  else
    false
  end
end

Zasadniczo sposób działania tej metody opisałem już wyżej, ale tak dla pewności:

  1. Wysyłamy żądanie nagłówka pod adres naszego filmiku
  2. Jeśli coś poszło nie tak – zakładamy, że URL nie jest poprawny
  3. Jeśli dostaliśmy nagłówek to go sprawdzamy
  4. Jeśli 200 – to znaczy że URL jest poprawny (true)
  5. Jeśli cokolwiek innego (404, 401, 403, 500, itd) – tzn. że już “umarł” (false)

4. set_cached_at_time

  def set_cached_at_time
    self.cached_at = Time.now
  end

Tutaj nie ma co tłumaczyć.

To by było na tyle jeśli chodzi o nasz model Video. Pozostaje nam jeszcze tylko plik main.rb.

Połączenie wszystkiego w całość

Na początek zaincludujmy pliki z katalogu lib/ oraz inne niezbędne nam biblioteki:

# coding: utf-8

def require_local(file)
  require File.join(File.dirname(__FILE__), "/lib/#{file}")
end

require 'rubygems'
require_local 'settings'
require_local 'facebook_bot'
require 'active_record'
require_local 'video'
require_local 'db_connector'

Zwróćcie uwagę, że dołączamy naszego FacebookBota z pierwszej części tego poradnika. Jednak jest to wersja lekko zmodyfikowana w stos. do wersji z części pierwszej. Różnica jest zasadniczo taka, że ta “nowa” wersja bota, oprócz URLa filmu pobiera także jego nazwę, dlatego radzę pobrać sobie paczkę ze źródełkami lub plik z botem z mojego githuba.

Dalej pobieramy z parametrów ID filmu oraz opcję “force” której użycie wymusi regenerację linku wprost z Facebooka, niezależnie od wartości cache’a:

video_id = ARGV[0]
force = false || ARGV[1] == 'true'

Dalej cała główna logika tej aplikacji:

video = Video.find_by_video_id(video_id)

# Jesli taki plik istnieje i jest poprawny i żądanie nie jest wymuszone
# to zwróć link
if video && video.valid? && !force
  puts 'Cache'
  puts video.url
else
  # Jesli link był niepoprawny lub jest to nowy filmik to zainicjuj FBbota
  # i pobierz z FB URL oraz nazwę filmiku
  fb = FacebookBot.new(SETTINGS[:fb_login], SETTINGS[:fb_pass])
  url = fb.video_url(video_id)
  name = fb.video_name(video_id)
  # Jesli video istniało tylko URL wygasł to przypisz nowy URL i nazwę
  # (nazwe na wypadek gdyby ulegla zmianie)
  if video
    video.url = url
    video.name = name
  else
    # Jesli filmiku nie bylo to go utworz
    video = Video.new(
      :video_id => video_id,
      :url => url,
      :name => name
    )
  end
  puts 'Nowe wywolanie'
  puts video.url
end
# Podbij ilosc wyswietlen
video.views+=1
# I Zapisz zmiany w modelu
video.save

Tyle. Od teraz mamy w pełni działający program umożliwiający “regenerację” linków do plików video z Facebooka. Dzięki cachowaniu w bazie danych ilość odpytań dla popularnych filmików znacznie spada.

Tutorial składa się z dwóch cześci:

  1. FacebookBot z wykorzystaniem Mechanize
  2. Cachowanie odpytań

Kod (nowszy i lepszy ;) ) dostępny na githubie.

Olderposts

Copyright © 2018 Running with Ruby

Theme by Anders NorenUp ↑