Matrix: add video/regular file upload

7 files changed, 445 insertions, 78 deletions

diff --git a/src/AsyncImageLoader.cpp b/src/AsyncImageLoader.cpp
index 020baf1..2fc33e8 100644
--- a/src/AsyncImageLoader.cpp
+++ b/src/AsyncImageLoader.cpp
@@ -63,10 +63,11 @@ namespace QuickMedia {
 
     // Returns empty string if no extension
     static const char* get_ext(const std::string &path) {
+        size_t slash_index = path.rfind('/');
         size_t index = path.rfind('.');
-        if(index == std::string::npos)
-            return "";
-        return path.c_str() + index;
+        if(index != std::string::npos && (slash_index == std::string::npos || index > slash_index))
+            return path.c_str() + index;
+        return "";
     }
 
     bool AsyncImageLoader::load_thumbnail(const std::string &url, bool local, sf::Vector2i resize_target_size, bool use_tor, std::shared_ptr<ThumbnailData> thumbnail_data) {
diff --git a/src/Body.cpp b/src/Body.cpp
index 6b352b3..4aa194b 100644
--- a/src/Body.cpp
+++ b/src/Body.cpp
@@ -473,6 +473,8 @@ namespace QuickMedia {
             if(item_thumbnail->loading_state == LoadingState::FINISHED_LOADING && item_thumbnail->image->getSize().x > 0 && item_thumbnail->image->getSize().y > 0) {
                 if(!item_thumbnail->texture.loadFromImage(*item_thumbnail->image))
                     fprintf(stderr, "Warning: failed to load texture from image: %s\n", item->thumbnail_url.c_str());
+                //item_thumbnail->texture.setSmooth(true);
+                //item_thumbnail->texture.generateMipmap();
                 item_thumbnail->image.reset();
                 item_thumbnail->loading_state = LoadingState::APPLIED_TO_TEXTURE;
             }
@@ -631,6 +633,8 @@ namespace QuickMedia {
             if(!item->visible && !item->get_description().empty())
                 item->visible = string_find_case_insensitive(item->get_description(), text);
         }
+
+        select_first_item();
     }
 
     bool Body::no_items_visible() const {
diff --git a/src/FileAnalyzer.cpp b/src/FileAnalyzer.cpp
new file mode 100644
index 0000000..690e40e
--- /dev/null
+++ b/src/FileAnalyzer.cpp
@@ -0,0 +1,227 @@
+#include "../include/FileAnalyzer.hpp"
+#include "../include/Program.h"
+#include <sys/stat.h>
+#include <stdio.h>
+#include <array>
+#include <json/reader.h> // TODO: Remove this dependency
+
+static const int MAGIC_NUMBER_BUFFER_SIZE = 36;
+
+namespace QuickMedia {
+    struct MagicNumber {
+        std::array<int, MAGIC_NUMBER_BUFFER_SIZE> data;
+        size_t size;
+        ContentType content_type;
+    };
+
+    // Sources:
+    // https://en.wikipedia.org/wiki/List_of_file_signatures
+    // https://mimesniff.spec.whatwg.org/
+
+    // What about audio ogg files that are not opus?
+    // TODO: Test all of these
+    static const std::array<MagicNumber, 19> magic_numbers = {
+        MagicNumber{ {'R', 'I', 'F', 'F', -1, -1, -1, -1, 'A', 'V', 'I', ' '}, 12, ContentType::VIDEO_AVI },
+        MagicNumber{ {0x00, 0x00, 0x00, -1, 'f', 't', 'y', 'p', 'i', 's', 'o', 'm'}, 12, ContentType::VIDEO_MP4 },
+        MagicNumber{ {0x1A, 0x45, 0xDF, 0xA3}, 4, ContentType::VIDEO_WEBM },
+        MagicNumber{ {'.', 's', 'n', 'd'}, 4, ContentType::AUDIO_BASIC },
+        MagicNumber{ {'F', 'O', 'R', 'M', -1, -1, -1, -1, 'A', 'I', 'F', 'F'}, 12, ContentType::AUDIO_AIFF },
+        MagicNumber{ { 'I', 'D', '3' }, 3, ContentType::AUDIO_MPEG },
+        MagicNumber{ { 0xFF, 0xFB }, 2, ContentType::AUDIO_MPEG },
+        MagicNumber{ { 0xFF, 0xF3 }, 2, ContentType::AUDIO_MPEG },
+        MagicNumber{ { 0xFF, 0xF2 }, 2, ContentType::AUDIO_MPEG },
+        //MagicNumber{ {'O', 'g', 'g', 'S', 0x00}, 5 },
+        MagicNumber{ {'M', 'T', 'h', 'd', -1, -1, -1, -1}, 8, ContentType::AUDIO_MIDI },
+        MagicNumber{ {'R', 'I', 'F', 'F', -1, -1, -1, -1, 'W', 'A', 'V', 'E'}, 12, ContentType::AUDIO_WAVE },
+        MagicNumber{ {'f', 'L', 'a', 'C'}, 4, ContentType::AUDIO_FLAC },
+        MagicNumber{ {'O', 'g', 'g', 'S', 0x00, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ,-1, -1, -1, -1, -1, -1, -1, 'O', 'p', 'u', 's', 'H', 'e', 'a', 'd'}, 36, ContentType::AUDIO_OPUS },
+        MagicNumber{ {0xFF, 0xD8, 0xFF}, 3, ContentType::IMAGE_JPEG },
+        MagicNumber{ {0x89, 'P', 'N', 'G', 0x0D, 0x0A, 0x1A, 0x0A}, 8, ContentType::IMAGE_PNG },
+        MagicNumber{ {'G', 'I', 'F', '8', '7', 'a'}, 6, ContentType::IMAGE_GIF },
+        MagicNumber{ {'G', 'I', 'F', '8', '9', 'a'}, 6, ContentType::IMAGE_GIF },
+        MagicNumber{ {'B', 'M'}, 2, ContentType::IMAGE_BMP },
+        MagicNumber{ {'R', 'I', 'F', 'F', -1, -1, -1, -1, 'W', 'E', 'B', 'V', 'P'}, 6, ContentType::IMAGE_WEBP }
+    };
+
+    bool is_content_type_video(ContentType content_type) {
+        return content_type >= ContentType::VIDEO_AVI && content_type <= ContentType::VIDEO_WEBM;
+    }
+
+    bool is_content_type_audio(ContentType content_type) {
+        return content_type >= ContentType::AUDIO_BASIC && content_type <= ContentType::AUDIO_OPUS;
+    }
+
+    bool is_content_type_image(ContentType content_type) {
+        return content_type >= ContentType::IMAGE_JPEG && content_type <= ContentType::IMAGE_WEBP;
+    }
+
+    const char* content_type_to_string(ContentType content_type) {
+        switch(content_type) {
+            case ContentType::UNKNOWN:      return "application/octet-stream";
+            case ContentType::VIDEO_AVI:    return "video/avi";
+            case ContentType::VIDEO_MP4:    return "video/mp4";
+            case ContentType::VIDEO_WEBM:   return "video/webm";
+            case ContentType::AUDIO_BASIC:  return "audio/basic";
+            case ContentType::AUDIO_AIFF:   return "audio/aiff";
+            case ContentType::AUDIO_MPEG:   return "audio/mpeg";
+            case ContentType::AUDIO_MIDI:   return "audio/midi";
+            case ContentType::AUDIO_WAVE:   return "audio/wave";
+            case ContentType::AUDIO_FLAC:   return "audio/wave";
+            case ContentType::AUDIO_OPUS:   return "audio/ogg";
+            case ContentType::IMAGE_JPEG:   return "image/jpeg";
+            case ContentType::IMAGE_PNG:    return "image/png";
+            case ContentType::IMAGE_GIF:    return "image/gif";
+            case ContentType::IMAGE_BMP:    return "image/bmp";
+            case ContentType::IMAGE_WEBP:   return "image/webp";
+        }
+        return "application/octet-stream";
+    }
+
+    static int accumulate_string(char *data, int size, void *userdata) {
+        std::string *str = (std::string*)userdata;
+        str->append(data, size);
+        return 0;
+    }
+
+    bool video_get_first_frame(const char *filepath, const char *destination_path) {
+        const char *program_args[] = { "ffmpeg", "-y", "-v", "quiet", "-i", filepath, "-vframes", "1", "-f", "singlejpeg", destination_path, nullptr };
+        std::string ffmpeg_result;
+        if(exec_program(program_args, nullptr, nullptr) != 0) {
+            fprintf(stderr, "Failed to execute ffmpeg, maybe its not installed?\n");
+            return false;
+        }
+        return true;
+    }
+
+    // TODO: Remove dependency on ffprobe
+    static bool ffprobe_extract_metadata(const char *filepath, std::optional<Dimensions> &dimensions, std::optional<double> &duration_seconds) {
+        const char *program_args[] = { "ffprobe", "-v", "quiet", "-print_format", "json", "-show_streams", "--", filepath, nullptr };
+        std::string ffprobe_result;
+        if(exec_program(program_args, accumulate_string, &ffprobe_result) != 0) {
+            fprintf(stderr, "Failed to execute ffprobe, maybe its not installed?\n");
+            return false;
+        }
+
+        Json::Value json_root;
+        Json::CharReaderBuilder json_builder;
+        std::unique_ptr<Json::CharReader> json_reader(json_builder.newCharReader());
+        std::string json_errors;
+        if(!json_reader->parse(&ffprobe_result[0], &ffprobe_result[ffprobe_result.size()], &json_root, &json_errors)) {
+            fprintf(stderr, "ffprobe response parsing failed: %s\n", json_errors.c_str());
+            return false;
+        }
+
+        if(!json_root.isObject())
+            return false;
+
+        const Json::Value &streams_json = json_root["streams"];
+        if(!streams_json.isArray())
+            return false;
+
+        for(const Json::Value &stream_json : streams_json) {
+            if(!stream_json.isObject())
+                continue;
+
+            const Json::Value &codec_type = stream_json["codec_type"];
+            if(!codec_type.isString())
+                continue;
+
+            if(strcmp(codec_type.asCString(), "video") == 0) {
+                const Json::Value &width_json = stream_json["width"];
+                const Json::Value &height_json = stream_json["height"];
+                const Json::Value &duration_json = stream_json["duration"];
+                if(width_json.isNumeric() && height_json.isNumeric())
+                    dimensions = { width_json.asInt(), height_json.asInt() };
+                if(duration_json.isString())
+                    duration_seconds = atof(duration_json.asCString());
+                break;
+            } else if(strcmp(codec_type.asCString(), "audio") == 0) {
+                const Json::Value &duration_json = stream_json["duration"];
+                if(duration_json.isString())
+                    duration_seconds = atof(duration_json.asCString());
+                // No break here because if there is video after this, we want it to overwrite this
+            }
+        }
+
+        return true;
+    }
+
+    FileAnalyzer::FileAnalyzer() : content_type(ContentType::UNKNOWN), file_size(0), loaded(false) {
+
+    }
+
+    bool FileAnalyzer::load_file(const char *filepath) {
+        if(loaded) {
+            fprintf(stderr, "File already loaded\n");
+            return false;
+        }
+
+        FILE *file = fopen(filepath, "rb");
+        if(!file) {
+            perror(filepath);
+            return false;
+        }
+
+        content_type = ContentType::UNKNOWN;
+        file_size = 0;
+        dimensions = std::nullopt;
+        duration_seconds = std::nullopt;
+
+        struct stat stat;
+        if(fstat(fileno(file), &stat) == -1) {
+            perror(filepath);
+            fclose(file);
+            return false;
+        }
+
+        file_size = stat.st_size;
+
+        unsigned char magic_number_buffer[MAGIC_NUMBER_BUFFER_SIZE];
+        size_t num_bytes_read = fread(magic_number_buffer, 1, sizeof(magic_number_buffer), file);
+        fclose(file);
+        
+        for(const MagicNumber &magic_number : magic_numbers) {
+            if(num_bytes_read >= magic_number.size) {
+                bool matching_magic_numbers = true;
+                for(size_t i = 0; i < magic_number.size; ++i) {
+                    if(magic_number.data[i] != (int)magic_number_buffer[i] && (int)magic_number.data[i] != -1) {
+                        matching_magic_numbers = false;
+                        break;
+                    }
+                }
+                if(matching_magic_numbers) {
+                    content_type = magic_number.content_type;
+                    break;
+                }
+            }
+        }
+
+        if(content_type != ContentType::UNKNOWN) {
+            if(!ffprobe_extract_metadata(filepath, dimensions, duration_seconds)) {
+                // This is not an error, matrix allows files to be uploaded without metadata
+                fprintf(stderr, "Failed to extract metadata from file: %s, is ffprobe not installed?\n", filepath);
+            }
+            if(is_content_type_image(content_type))
+                duration_seconds = std::nullopt;
+        }
+
+        loaded = true;
+        return true;
+    }
+
+    ContentType FileAnalyzer::get_content_type() const {
+        return content_type;
+    }
+
+    size_t FileAnalyzer::get_file_size() const {
+        return file_size;
+    }
+
+    std::optional<Dimensions> FileAnalyzer::get_dimensions() const {
+        return dimensions;
+    }
+
+    std::optional<double> FileAnalyzer::get_duration_seconds() const {
+        return duration_seconds;
+    }
+}
\ No newline at end of file
diff --git a/src/ImageViewer.cpp b/src/ImageViewer.cpp
index 24894fd..77c53b4 100644
--- a/src/ImageViewer.cpp
+++ b/src/ImageViewer.cpp
@@ -261,6 +261,8 @@ namespace QuickMedia {
             if(page_data) {
                 if(page_data->image_status == ImageStatus::LOADED && page_data->image->getSize().x > 0 && page_data->image->getSize().y > 0) {
                     if(page_data->texture.loadFromImage(*page_data->image)) {
+                        //page_data->texture.setSmooth(true);
+                        //page_data->texture.generateMipmap();
                         double height_before = get_page_size(page_i).y;
                         page_data->image_status = ImageStatus::APPLIED_TO_TEXTURE;
                         page_data->sprite.setTexture(page_data->texture, true);
diff --git a/src/QuickMedia.cpp b/src/QuickMedia.cpp
index 8835b1d..fd49556 100644
--- a/src/QuickMedia.cpp
+++ b/src/QuickMedia.cpp
@@ -3117,6 +3117,7 @@ namespace QuickMedia {
                     
                     if(attached_image_texture->loadFromMemory(image_data.data(), image_data.size())) {
                         attached_image_texture->setSmooth(true);
+                        //attached_image_texture->generateMipmap();
                         attached_image_sprite.setTexture(*attached_image_texture, true);
                     } else {
                         BodyItem *selected_item = body->get_selected();
@@ -3280,14 +3281,17 @@ namespace QuickMedia {
             source.a + diff_a * progress);
     }
 
-    static std::string extract_first_line(const std::string &str) {
+    static std::string extract_first_line(const std::string &str, size_t max_length) {
         size_t index = str.find('\n');
-        if(index == std::string::npos)
+        if(index == std::string::npos) {
+            if(str.size() > max_length)
+                return str.substr(0, max_length) + "...";
             return str;
-        else if(index == 0)
+        } else if(index == 0) {
             return "";
-        else
-            return str.substr(0, index);
+        } else {
+            return str.substr(0, std::min(index, max_length)) + "...";
+        }
     }
 
     void Program::chat_page() {
@@ -3361,7 +3365,7 @@ namespace QuickMedia {
                 if(only_show_mentions) {
                     std::string room_desc;
                     if(!messages.empty())
-                        room_desc = matrix->message_get_author_displayname(room, messages.back().get()) + ": " + extract_first_line(messages.back()->body);
+                        room_desc = matrix->message_get_author_displayname(room, messages.back().get()) + ": " + extract_first_line(messages.back()->body, 150);
                     if(was_mentioned) {
                         room_desc += "\n** You were mentioned **"; // TODO: Better notification?
                         room_body_item_it->second.body_item->title_color = sf::Color(255, 100, 100);
@@ -3369,7 +3373,7 @@ namespace QuickMedia {
                     }
                     room_body_item_it->second.body_item->set_description(std::move(room_desc));
                 } else if(!messages.empty()) {
-                    std::string room_desc = "Unread: " + matrix->message_get_author_displayname(room, messages.back().get()) + ": " + extract_first_line(messages.back()->body);
+                    std::string room_desc = "Unread: " + matrix->message_get_author_displayname(room, messages.back().get()) + ": " + extract_first_line(messages.back()->body, 150);
                     if(was_mentioned)
                         room_desc += "\n** You were mentioned **"; // TODO: Better notification?
                     room_body_item_it->second.body_item->set_description(std::move(room_desc));
@@ -3409,7 +3413,7 @@ namespace QuickMedia {
                 if(text.isEmpty())
                     return false;
 
-                if(text[0] == '/') {
+                if(chat_state == ChatState::TYPING_MESSAGE && text[0] == '/') {
                     std::string command = text;
                     strip(command);
                     if(command == "/upload") {
@@ -3432,7 +3436,7 @@ namespace QuickMedia {
 
                 if(chat_state == ChatState::TYPING_MESSAGE) {
                     // TODO: Make asynchronous
-                    if(matrix->post_message(current_room_id, text) == PluginResult::OK) {
+                    if(matrix->post_message(current_room_id, text, std::nullopt, std::nullopt) == PluginResult::OK) {
                         chat_input.set_editable(false);
                         chat_state = ChatState::NAVIGATING;
                         return true;
@@ -3575,11 +3579,18 @@ namespace QuickMedia {
             }
         };
 
+        bool is_window_focused = true;
+
         while (current_page == Page::CHAT) {
             sf::Int32 frame_time_ms = frame_timer.restart().asMilliseconds();
             while (window.pollEvent(event)) {
                 base_event_handler(event, Page::EXIT, false, false, false);
-                if(event.type == sf::Event::Resized || event.type == sf::Event::GainedFocus) {
+                if(event.type == sf::Event::GainedFocus) {
+                    is_window_focused = true;
+                    redraw = true;
+                } else if(event.type == sf::Event::LostFocus) {
+                    is_window_focused = false;
+                } else if(event.type == sf::Event::Resized || event.type == sf::Event::GainedFocus) {
                     redraw = true;
                 } else if(event.type == sf::Event::KeyPressed && chat_state == ChatState::NAVIGATING) {
                     if(event.key.code == sf::Keyboard::Up || event.key.code == sf::Keyboard::PageUp || event.key.code == sf::Keyboard::Home) {
@@ -3833,8 +3844,11 @@ namespace QuickMedia {
                     } else {
                         // TODO: Make asynchronous.
                         // TODO: Upload multiple files.
-                        if(matrix->post_file(current_room_id, selected_files[0]) != PluginResult::OK)
-                            show_notification("QuickMedia", "Failed to upload image to room", Urgency::CRITICAL);
+                        std::string err_msg;
+                        if(matrix->post_file(current_room_id, selected_files[0], err_msg) != PluginResult::OK) {
+                            std::string desc = "Failed to upload image to room, error: " + err_msg;
+                            show_notification("QuickMedia", desc.c_str(), Urgency::CRITICAL);
+                        }
                     }
                     redraw = true;
                     break;
@@ -3887,6 +3901,8 @@ namespace QuickMedia {
             if(room_avatar_thumbnail_data->loading_state == LoadingState::FINISHED_LOADING && room_avatar_thumbnail_data->image->getSize().x > 0 && room_avatar_thumbnail_data->image->getSize().y > 0) {
                 if(!room_avatar_thumbnail_data->texture.loadFromImage(*room_avatar_thumbnail_data->image))
                     fprintf(stderr, "Warning: failed to load texture for room avatar\n");
+                room_avatar_thumbnail_data->texture.setSmooth(true);
+                //room_avatar_thumbnail_data->texture.generateMipmap();
                 room_avatar_thumbnail_data->image.reset();
                 room_avatar_thumbnail_data->loading_state = LoadingState::APPLIED_TO_TEXTURE;
                 room_avatar_sprite.setTexture(room_avatar_thumbnail_data->texture, true);
@@ -4152,7 +4168,7 @@ namespace QuickMedia {
 
             if(tabs[selected_tab].type == ChatTabType::MESSAGES) {
                 BodyItem *last_visible_item = tabs[selected_tab].body->get_last_fully_visible_item();
-                if(chat_state != ChatState::URL_SELECTION && current_room_body_data && last_visible_item && !setting_read_marker && read_marker_timer.getElapsedTime().asMilliseconds() >= read_marker_timeout_ms) {
+                if(is_window_focused && chat_state != ChatState::URL_SELECTION && current_room_body_data && last_visible_item && !setting_read_marker && read_marker_timer.getElapsedTime().asMilliseconds() >= read_marker_timeout_ms) {
                     Message *message = (Message*)last_visible_item->userdata;
                     if(message->timestamp > current_room_body_data->last_read_message_timestamp) {
                         current_room_body_data->last_read_message_timestamp = message->timestamp;
diff --git a/src/main.cpp b/src/main.cpp
index 2899565..3383363 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -5,6 +5,7 @@
 
 int main(int argc, char **argv) {
     chdir(dirname(argv[0]));
+    setlocale(LC_ALL, "C"); // Sigh... stupid C
     XInitThreads();
     QuickMedia::Program program;
     return program.run(argc, argv);
diff --git a/src/plugins/Matrix.cpp b/src/plugins/Matrix.cpp
index e182c11..60fc8a9 100644
--- a/src/plugins/Matrix.cpp
+++ b/src/plugins/Matrix.cpp
@@ -1,6 +1,5 @@
 #include "../../plugins/Matrix.hpp"
 #include "../../include/Storage.hpp"
-#include "../../include/ImageUtils.hpp"
 #include <json/reader.h>
 #include <json/writer.h>
 #include <fcntl.h>
@@ -742,16 +741,18 @@ namespace QuickMedia {
         return result.str();
     }
 
-    static const char* message_type_to_request_msg_type_str(MessageType msgtype) {
-        switch(msgtype) {
-            case MessageType::TEXT:     return "m.text";
-            case MessageType::IMAGE:    return "m.image";
-            case MessageType::VIDEO:    return "m.video";
-        }
-        return "m.text";
+    static const char* content_type_to_message_type(ContentType content_type) {
+        if(is_content_type_video(content_type))
+            return "m.video";
+        else if(is_content_type_audio(content_type))
+            return "m.audio";
+        else if(is_content_type_image(content_type))
+            return "m.image";
+        else
+            return "m.file";
     }
 
-    PluginResult Matrix::post_message(const std::string &room_id, const std::string &body, const std::string &url, MessageType msgtype, MessageInfo *info) {
+    PluginResult Matrix::post_message(const std::string &room_id, const std::string &body, const std::optional<UploadInfo> &file_info, const std::optional<UploadInfo> &thumbnail_info) {
         char random_characters[18];
         if(!generate_random_characters(random_characters, sizeof(random_characters)))
             return PluginResult::ERR;
@@ -760,7 +761,7 @@ namespace QuickMedia {
 
         std::string formatted_body;
         bool contains_formatted_text = false;
-        if(msgtype == MessageType::TEXT) {
+        if(!file_info) {
             int line = 0;
             string_split(body, '\n', [&formatted_body, &contains_formatted_text, &line](const char *str, size_t size){
                 if(line > 0)
@@ -781,22 +782,42 @@ namespace QuickMedia {
         }
 
         Json::Value request_data(Json::objectValue);
-        request_data["msgtype"] = message_type_to_request_msg_type_str(msgtype);
+        request_data["msgtype"] = (file_info ? content_type_to_message_type(file_info->content_type) : "m.text");
         request_data["body"] = body;
         if(contains_formatted_text) {
             request_data["format"] = "org.matrix.custom.html";
             request_data["formatted_body"] = std::move(formatted_body);
         }
-        if(msgtype == MessageType::IMAGE) {
-            if(info) {
-                Json::Value info_json(Json::objectValue);
-                info_json["size"] = info->size;
-                info_json["w"] = info->w;
-                info_json["h"] = info->h;
-                info_json["mimetype"] = info->mimetype;
-                request_data["info"] = std::move(info_json);
+
+        // TODO: Add hashblur?
+        if(file_info) {
+            Json::Value info_json(Json::objectValue);
+            info_json["size"] = file_info->file_size;
+            info_json["mimetype"] = content_type_to_string(file_info->content_type);
+            if(file_info->dimensions) {
+                info_json["w"] = file_info->dimensions->width;
+                info_json["h"] = file_info->dimensions->height;
             }
-            request_data["url"] = url;
+            if(file_info->duration_seconds) {
+                // TODO: Check for overflow?
+                info_json["duration"] = (int)file_info->duration_seconds.value() * 1000;
+            }
+
+            if(thumbnail_info) {
+                Json::Value thumbnail_info_json(Json::objectValue);
+                thumbnail_info_json["size"] = thumbnail_info->file_size;
+                thumbnail_info_json["mimetype"] = content_type_to_string(thumbnail_info->content_type);
+                if(thumbnail_info->dimensions) {
+                    thumbnail_info_json["w"] = thumbnail_info->dimensions->width;
+                    thumbnail_info_json["h"] = thumbnail_info->dimensions->height;
+                }
+
+                info_json["thumbnail_url"] = thumbnail_info->content_uri;
+                info_json["info"] = std::move(thumbnail_info_json);
+            }
+
+            request_data["info"] = std::move(info_json);
+            request_data["url"] = file_info->content_uri;
         }
 
         Json::StreamWriterBuilder builder;
@@ -902,7 +923,7 @@ namespace QuickMedia {
         relates_to_json["m.in_reply_to"] = std::move(in_reply_to_json);
 
         Json::Value request_data(Json::objectValue);
-        request_data["msgtype"] = message_type_to_request_msg_type_str(MessageType::TEXT);
+        request_data["msgtype"] = "m.text"; // TODO: Allow image reply? element doesn't do that but we could!
         request_data["body"] = create_body_for_message_reply(room_it->second.get(), relates_to_message_raw, body); // Yes, the reply is to the edited message but the event_id reference is to the original message...
         request_data["m.relates_to"] = std::move(relates_to_json);
 
@@ -1002,7 +1023,7 @@ namespace QuickMedia {
         relates_to_json["rel_type"] = "m.replace";
 
         Json::Value request_data(Json::objectValue);
-        request_data["msgtype"] = message_type_to_request_msg_type_str(MessageType::TEXT);
+        request_data["msgtype"] = "m.text"; // TODO: Allow other types of edits
         request_data["body"] = " * " + body;
         if(contains_formatted_text) {
             request_data["format"] = "org.matrix.custom.html";
@@ -1157,82 +1178,129 @@ namespace QuickMedia {
         return filename;
     }
 
-    static const char* image_type_to_mimetype(ImageType image_type) {
-        switch(image_type) {
-            case ImageType::PNG:    return "image/png";
-            case ImageType::GIF:    return "image/gif";
-            case ImageType::JPG:    return "image/jpeg";
-        }
-        return "application/octet-stream";
+    PluginResult Matrix::post_file(const std::string &room_id, const std::string &filepath, std::string &err_msg) {
+        UploadInfo file_info;
+        UploadInfo thumbnail_info;
+        PluginResult upload_file_result = upload_file(room_id, filepath, file_info, thumbnail_info, err_msg);
+        if(upload_file_result != PluginResult::OK)
+            return upload_file_result;
+
+        std::optional<UploadInfo> file_info_opt = std::move(file_info);
+        std::optional<UploadInfo> thumbnail_info_opt;
+        if(!thumbnail_info.content_uri.empty())
+            thumbnail_info_opt = std::move(thumbnail_info);
+
+        const char *filename = file_get_filename(filepath);
+        return post_message(room_id, filename, file_info_opt, thumbnail_info_opt);
     }
 
-    PluginResult Matrix::post_file(const std::string &room_id, const std::string &filepath) {
-        int image_width, image_height;
-        ImageType image_type;
-        if(!image_get_resolution(filepath, &image_width, &image_height, &image_type)) {
-            fprintf(stderr, "Failed to get resolution of image: %s. Only image uploads are currently supported\n", filepath.c_str());
+    PluginResult Matrix::upload_file(const std::string &room_id, const std::string &filepath, UploadInfo &file_info, UploadInfo &thumbnail_info, std::string &err_msg) {
+        FileAnalyzer file_analyzer;
+        if(!file_analyzer.load_file(filepath.c_str())) {
+            err_msg = "Failed to load " + filepath;
             return PluginResult::ERR;
         }
 
-        const char *mimetype = image_type_to_mimetype(image_type);
+        file_info.content_type = file_analyzer.get_content_type();
+        file_info.file_size = file_analyzer.get_file_size();
+        file_info.dimensions = file_analyzer.get_dimensions();
+        file_info.duration_seconds = file_analyzer.get_duration_seconds();
 
-        // TODO: What if the file changes after this? is the file size really needed?
-        size_t file_size;
-        if(file_get_size(filepath, &file_size) != 0) {
-            fprintf(stderr, "Failed to get size of image: %s\n", filepath.c_str());
+        int upload_limit;
+        PluginResult config_result = get_config(&upload_limit);
+        if(config_result != PluginResult::OK) {
+            err_msg = "Failed to get file size limit from server";
+            return config_result;
+        }
+
+        // Checking for sane file size limit client side, to prevent loading a huge file and crashing
+        if(file_analyzer.get_file_size() > 300 * 1024 * 1024) { // 300mb
+            err_msg = "File is too large! client-side limit is set to 300mb";
             return PluginResult::ERR;
         }
 
-        // TODO: Check server file limit first: GET https://glowers.club/_matrix/media/r0/config
-        // and also have a sane limit client-side.
-        if(file_size > 100 * 1024 * 1024) {
-            fprintf(stderr, "Upload file size it too large!, max size is currently 100mb\n");
+        if((int)file_analyzer.get_file_size() > upload_limit) {
+            err_msg = "File is too large! max upload size on your homeserver is " + std::to_string(upload_limit) + " bytes, the file you tried to upload is " + std::to_string(file_analyzer.get_file_size()) + " bytes";
             return PluginResult::ERR;
         }
 
+        if(is_content_type_video(file_analyzer.get_content_type())) {
+            // TODO: Also upload thumbnail for images. Take into consideration below upload_file, we dont want to upload thumbnail of thumbnail
+            char tmp_filename[] = "/tmp/quickmedia_video_frame_XXXXXX";
+            int tmp_file = mkstemp(tmp_filename);
+            if(tmp_file != -1) {
+                if(video_get_first_frame(filepath.c_str(), tmp_filename)) {
+                    UploadInfo upload_info_ignored; // Ignore because it wont be set anyways. Thumbnails dont have thumbnails.
+                    PluginResult upload_thumbnail_result = upload_file(room_id, tmp_filename, thumbnail_info, upload_info_ignored, err_msg);
+                    if(upload_thumbnail_result != PluginResult::OK) {
+                        close(tmp_file);
+                        remove(tmp_filename);
+                        return upload_thumbnail_result;
+                    }
+                } else {
+                    fprintf(stderr, "Failed to get first frame of video, ignoring thumbnail...\n");
+                }
+                close(tmp_file);
+                remove(tmp_filename);
+            } else {
+                fprintf(stderr, "Failed to create temporary file for video thumbnail, ignoring thumbnail...\n");
+            }
+        }
+
         std::vector<CommandArg> additional_args = {
             { "-X", "POST" },
-            { "-H", std::string("content-type: ") + mimetype },
+            { "-H", std::string("content-type: ") + content_type_to_string(file_analyzer.get_content_type()) },
             { "-H", "Authorization: Bearer " + access_token },
             { "--data-binary", "@" + filepath }
         };
 
         const char *filename = file_get_filename(filepath);
+        std::string filename_escaped = url_param_encode(filename);
 
         char url[512];
-        snprintf(url, sizeof(url), "%s/_matrix/media/r0/upload?filename=%s", homeserver.c_str(), filename);
+        snprintf(url, sizeof(url), "%s/_matrix/media/r0/upload?filename=%s", homeserver.c_str(), filename_escaped.c_str());
         fprintf(stderr, "Upload url: |%s|\n", url);
 
         std::string server_response;
-        if(download_to_string(url, server_response, std::move(additional_args), use_tor, true) != DownloadResult::OK)
+        if(download_to_string(url, server_response, std::move(additional_args), use_tor, true, false) != DownloadResult::OK) {
+            err_msg = "Upload request failed, reason: " + server_response;
             return PluginResult::NET_ERR;
+        }
 
-        if(server_response.empty())
+        if(server_response.empty()) {
+            err_msg = "Got corrupt response from server";
             return PluginResult::ERR;
+        }
 
         Json::Value json_root;
         Json::CharReaderBuilder json_builder;
         std::unique_ptr<Json::CharReader> json_reader(json_builder.newCharReader());
         std::string json_errors;
         if(!json_reader->parse(&server_response[0], &server_response[server_response.size()], &json_root, &json_errors)) {
-            fprintf(stderr, "Matrix upload response parse error: %s\n", json_errors.c_str());
+            err_msg = "Matrix upload response parse error: " + json_errors;
             return PluginResult::ERR;
         }
 
-        if(!json_root.isObject())
+        if(!json_root.isObject()) {
+            err_msg = "Got corrupt response from server";
+            return PluginResult::ERR;
+        }
+
+        const Json::Value &error_json = json_root["error"];
+        if(error_json.isString()) {
+            err_msg = error_json.asString();
             return PluginResult::ERR;
+        }
 
         const Json::Value &content_uri_json = json_root["content_uri"];
-        if(!content_uri_json.isString())
+        if(!content_uri_json.isString()) {
+            err_msg = "Missing content_uri is server response";
             return PluginResult::ERR;
+        }
 
         fprintf(stderr, "Matrix upload, response content uri: %s\n", content_uri_json.asCString());
-        MessageInfo message_info;
-        message_info.size = file_size;
-        message_info.w = image_width;
-        message_info.h = image_height;
-        message_info.mimetype = mimetype;
-        return post_message(room_id, filename, content_uri_json.asString(), MessageType::IMAGE, &message_info);
+        file_info.content_uri = content_uri_json.asString();
+        return PluginResult::OK;
     }
 
     PluginResult Matrix::login(const std::string &username, const std::string &password, const std::string &homeserver, std::string &err_msg) {
@@ -1279,9 +1347,9 @@ namespace QuickMedia {
             return PluginResult::ERR;
         }
 
-        const Json::Value &error = json_root["error"];
-        if(error.isString()) {
-            err_msg = error.asString();
+        const Json::Value &error_json = json_root["error"];
+        if(error_json.isString()) {
+            err_msg = error_json.asString();
             return PluginResult::ERR;
         }
 
@@ -1340,6 +1408,7 @@ namespace QuickMedia {
         username.clear();
         access_token.clear();
         homeserver.clear();
+        upload_limit.reset();
         next_batch.clear();
 
         return PluginResult::OK;
@@ -1394,9 +1463,9 @@ namespace QuickMedia {
             return PluginResult::ERR;
         }
 
-        const Json::Value &error = json_root["error"];
-        if(error.isString()) {
-            err_msg = error.asString();
+        const Json::Value &error_json = json_root["error"];
+        if(error_json.isString()) {
+            err_msg = error_json.asString();
             return PluginResult::ERR;
         }
 
@@ -1554,4 +1623,51 @@ namespace QuickMedia {
         }
         return room_data->user_info[message->user_id].display_name;
     }
+
+    PluginResult Matrix::get_config(int *upload_size) {
+        // TODO: What if the upload limit changes? is it possible for the upload limit to change while the server is running?
+        if(upload_limit) {
+            *upload_size = upload_limit.value();
+            return PluginResult::OK;
+        }
+
+        *upload_size = 0;
+
+        std::vector<CommandArg> additional_args = {
+            { "-H", "Authorization: Bearer " + access_token }
+        };
+
+        char url[512];
+        snprintf(url, sizeof(url), "%s/_matrix/media/r0/config", homeserver.c_str());
+        fprintf(stderr, "load initial room data, url: |%s|\n", url);
+
+        std::string server_response;
+        if(download_to_string(url, server_response, std::move(additional_args), use_tor, true) != DownloadResult::OK) {
+            fprintf(stderr, "Matrix /config failed\n");
+            return PluginResult::NET_ERR;
+        }
+
+        if(server_response.empty())
+            return PluginResult::ERR;
+
+        Json::Value json_root;
+        Json::CharReaderBuilder json_builder;
+        std::unique_ptr<Json::CharReader> json_reader(json_builder.newCharReader());
+        std::string json_errors;
+        if(!json_reader->parse(&server_response[0], &server_response[server_response.size()], &json_root, &json_errors)) {
+            fprintf(stderr, "Matrix parsing /config response failed, error: %s\n", json_errors.c_str());
+            return PluginResult::ERR;
+        }
+
+        if(!json_root.isObject())
+            return PluginResult::ERR;
+
+        const Json::Value &upload_size_json = json_root["m.upload.size"];
+        if(!upload_size_json.isNumeric())
+            return PluginResult::ERR;
+
+        upload_limit = upload_size_json.asInt();
+        *upload_size = upload_limit.value();
+        return PluginResult::OK;
+    }
 }
\ No newline at end of file