git.squeep.com Git - akkoma/blob - lib/pleroma/helpers/media_helper.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Helpers.MediaHelper do
   6   @moduledoc """
   7   Handles common media-related operations.
   8   """
   9
  10   alias Pleroma.HTTP
  11
  12   def image_resize(url, options) do
  13     with executable when is_binary(executable) <- System.find_executable("convert"),
  14          {:ok, args} <- prepare_image_resize_args(options),
  15          {:ok, env} <- HTTP.get(url, [], pool: :media),
  16          {:ok, fifo_path} <- mkfifo() do
  17       args = List.flatten([fifo_path, args])
  18       run_fifo(fifo_path, env, executable, args)
  19     else
  20       nil -> {:error, {:convert, :command_not_found}}
  21       {:error, _} = error -> error
  22     end
  23   end
  24
  25   defp prepare_image_resize_args(
  26          %{max_width: max_width, max_height: max_height, format: "png"} = options
  27        ) do
  28     quality = options[:quality] || 85
  29     resize = Enum.join([max_width, "x", max_height, ">"])
  30
  31     args = [
  32       "-resize",
  33       resize,
  34       "-quality",
  35       to_string(quality),
  36       "png:-"
  37     ]
  38
  39     {:ok, args}
  40   end
  41
  42   defp prepare_image_resize_args(%{max_width: max_width, max_height: max_height} = options) do
  43     quality = options[:quality] || 85
  44     resize = Enum.join([max_width, "x", max_height, ">"])
  45
  46     args = [
  47       "-interlace",
  48       "Plane",
  49       "-resize",
  50       resize,
  51       "-quality",
  52       to_string(quality),
  53       "jpg:-"
  54     ]
  55
  56     {:ok, args}
  57   end
  58
  59   defp prepare_image_resize_args(_), do: {:error, :missing_options}
  60
  61   # Note: video thumbnail is intentionally not resized (always has original dimensions)
  62   def video_framegrab(url) do
  63     with executable when is_binary(executable) <- System.find_executable("ffmpeg"),
  64          {:ok, env} <- HTTP.get(url, [], pool: :media),
  65          {:ok, fifo_path} <- mkfifo(),
  66          args = [
  67            "-y",
  68            "-i",
  69            fifo_path,
  70            "-vframes",
  71            "1",
  72            "-f",
  73            "mjpeg",
  74            "-loglevel",
  75            "error",
  76            "-"
  77          ] do
  78       run_fifo(fifo_path, env, executable, args)
  79     else
  80       nil -> {:error, {:ffmpeg, :command_not_found}}
  81       {:error, _} = error -> error
  82     end
  83   end
  84
  85   defp run_fifo(fifo_path, env, executable, args) do
  86     pid =
  87       Port.open({:spawn_executable, executable}, [
  88         :use_stdio,
  89         :stream,
  90         :exit_status,
  91         :binary,
  92         args: args
  93       ])
  94
  95     fifo = Port.open(to_charlist(fifo_path), [:eof, :binary, :stream, :out])
  96     fix = Pleroma.Helpers.QtFastStart.fix(env.body)
  97     true = Port.command(fifo, fix)
  98     :erlang.port_close(fifo)
  99     loop_recv(pid)
 100   after
 101     File.rm(fifo_path)
 102   end
 103
 104   defp mkfifo do
 105     path = Path.join(System.tmp_dir!(), "pleroma-media-preview-pipe-#{Ecto.UUID.generate()}")
 106
 107     case System.cmd("mkfifo", [path]) do
 108       {_, 0} ->
 109         spawn(fifo_guard(path))
 110         {:ok, path}
 111
 112       {_, err} ->
 113         {:error, {:fifo_failed, err}}
 114     end
 115   end
 116
 117   defp fifo_guard(path) do
 118     pid = self()
 119
 120     fn ->
 121       ref = Process.monitor(pid)
 122
 123       receive do
 124         {:DOWN, ^ref, :process, ^pid, _} ->
 125           File.rm(path)
 126       end
 127     end
 128   end
 129
 130   defp loop_recv(pid) do
 131     loop_recv(pid, <<>>)
 132   end
 133
 134   defp loop_recv(pid, acc) do
 135     receive do
 136       {^pid, {:data, data}} ->
 137         loop_recv(pid, acc <> data)
 138
 139       {^pid, {:exit_status, 0}} ->
 140         {:ok, acc}
 141
 142       {^pid, {:exit_status, status}} ->
 143         {:error, status}
 144     after
 145       5000 ->
 146         :erlang.port_close(pid)
 147         {:error, :timeout}
 148     end
 149   end
 150 end