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