git.sesse.net Git - nageru/blob - image_input.cpp

   1 #include "image_input.h"
   2
   3 #include <movit/image_format.h>
   4
   5 extern "C" {
   6 #include <libavcodec/avcodec.h>
   7 #include <libavformat/avformat.h>
   8 #include <libavutil/imgutils.h>
   9 #include <libavutil/pixfmt.h>
  10 #include <libswscale/swscale.h>
  11 }
  12
  13 #include <sys/types.h>
  14 #include <sys/stat.h>
  15 #include <unistd.h>
  16 #include <fcntl.h>
  17
  18 #include <mutex>
  19 #include <thread>
  20
  21 #include "flags.h"
  22
  23 using namespace std;
  24
  25 namespace {
  26
  27 string search_for_file(const string &filename)
  28 {
  29         // Look for the file in all theme_dirs until we find one;
  30         // that will be the permanent resolution of this file, whether
  31         // it is actually valid or not.
  32         // We store errors from all the attempts, and show them
  33         // once we know we can't find any of them.
  34         vector<string> errors;
  35         for (const string &dir : global_flags.theme_dirs) {
  36                 string pathname = dir + "/" + filename;
  37                 if (access(pathname.c_str(), O_RDONLY) == 0) {
  38                         return pathname;
  39                 } else {
  40                         char buf[512];
  41                         snprintf(buf, sizeof(buf), "%s: %s", pathname.c_str(), strerror(errno));
  42                         errors.push_back(buf);
  43                 }
  44         }
  45
  46         for (const string &error : errors) {
  47                 fprintf(stderr, "%s\n", error.c_str());
  48         }
  49         fprintf(stderr, "Couldn't find %s in any directory in --theme-dirs, exiting.\n",
  50                 filename.c_str());
  51         exit(1);
  52 }
  53
  54 }  // namespace
  55
  56 ImageInput::ImageInput(const string &filename)
  57         : movit::FlatInput({movit::COLORSPACE_sRGB, movit::GAMMA_sRGB}, movit::FORMAT_RGBA_POSTMULTIPLIED_ALPHA,
  58                            GL_UNSIGNED_BYTE, 1280, 720),  // FIXME
  59           pathname(search_for_file(filename)),
  60           current_image(load_image(pathname))
  61 {
  62         if (current_image == nullptr) {  // Could happen even though search_for_file() returned.
  63                 fprintf(stderr, "Couldn't load image, exiting.\n");
  64                 exit(1);
  65         }
  66         set_pixel_data(current_image->pixels.get());
  67 }
  68
  69 void ImageInput::set_gl_state(GLuint glsl_program_num, const string& prefix, unsigned *sampler_num)
  70 {
  71         // See if the background thread has given us a new version of our image.
  72         // Note: The old version might still be lying around in other ImageInputs
  73         // (in fact, it's likely), but at least the total amount of memory used
  74         // is bounded. Currently we don't even share textures between them,
  75         // so there's a fair amount of OpenGL memory waste anyway (the cache
  76         // is mostly there to save startup time, not RAM).
  77         {
  78                 unique_lock<mutex> lock(all_images_lock);
  79                 if (all_images[pathname] != current_image) {
  80                         current_image = all_images[pathname];
  81                         set_pixel_data(current_image->pixels.get());
  82                 }
  83         }
  84         movit::FlatInput::set_gl_state(glsl_program_num, prefix, sampler_num);
  85 }
  86
  87 shared_ptr<const ImageInput::Image> ImageInput::load_image(const string &pathname)
  88 {
  89         unique_lock<mutex> lock(all_images_lock);  // Held also during loading.
  90         if (all_images.count(pathname)) {
  91                 return all_images[pathname];
  92         }
  93
  94         all_images[pathname] = load_image_raw(pathname);
  95         timespec first_modified = all_images[pathname]->last_modified;
  96         update_threads[pathname] =
  97                 thread(bind(update_thread_func, pathname, first_modified));
  98
  99         return all_images[pathname];
 100 }
 101
 102 // Some helpers to make RAII versions of FFmpeg objects.
 103 // The cleanup functions don't interact all that well with unique_ptr,
 104 // so things get a bit messy and verbose, but overall it's worth it to ensure
 105 // we never leak things by accident in error paths.
 106
 107 namespace {
 108
 109 void avformat_close_input_unique(AVFormatContext *format_ctx)
 110 {
 111         avformat_close_input(&format_ctx);
 112 }
 113
 114 unique_ptr<AVFormatContext, decltype(avformat_close_input_unique)*>
 115 avformat_open_input_unique(const char *pathname,
 116                            AVInputFormat *fmt, AVDictionary **options)
 117 {
 118         AVFormatContext *format_ctx = nullptr;
 119         if (avformat_open_input(&format_ctx, pathname, fmt, options) != 0) {
 120                 format_ctx = nullptr;
 121         }
 122         return unique_ptr<AVFormatContext, decltype(avformat_close_input_unique)*>(
 123                 format_ctx, avformat_close_input_unique);
 124 }
 125
 126 void av_frame_free_unique(AVFrame *frame)
 127 {
 128         av_frame_free(&frame);
 129 }
 130
 131 unique_ptr<AVFrame, decltype(av_frame_free_unique)*>
 132 av_frame_alloc_unique()
 133 {
 134         AVFrame *frame = av_frame_alloc();
 135         return unique_ptr<AVFrame, decltype(av_frame_free_unique)*>(
 136                 frame, av_frame_free_unique);
 137 }
 138
 139 }  // namespace
 140
 141 shared_ptr<const ImageInput::Image> ImageInput::load_image_raw(const string &pathname)
 142 {
 143         // Note: Call before open, not after; otherwise, there's a race.
 144         // (There is now, too, but it tips the correct way. We could use fstat()
 145         // if we had the file descriptor.)
 146         struct stat buf;
 147         if (stat(pathname.c_str(), &buf) != 0) {
 148                 fprintf(stderr, "%s: Error stat-ing file\n", pathname.c_str());
 149                 return nullptr;
 150         }
 151         timespec last_modified = buf.st_mtim;
 152
 153         auto format_ctx = avformat_open_input_unique(pathname.c_str(), nullptr, nullptr);
 154         if (format_ctx == nullptr) {
 155                 fprintf(stderr, "%s: Error opening file\n", pathname.c_str());
 156                 return nullptr;
 157         }
 158
 159         if (avformat_find_stream_info(format_ctx.get(), nullptr) < 0) {
 160                 fprintf(stderr, "%s: Error finding stream info\n", pathname.c_str());
 161                 return nullptr;
 162         }
 163
 164         int stream_index = -1;
 165         for (unsigned i = 0; i < format_ctx->nb_streams; ++i) {
 166                 if (format_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
 167                         stream_index = i;
 168                         break;
 169                 }
 170         }
 171         if (stream_index == -1) {
 172                 fprintf(stderr, "%s: No video stream found\n", pathname.c_str());
 173                 return nullptr;
 174         }
 175
 176         AVCodecContext *codec_ctx = format_ctx->streams[stream_index]->codec;
 177         AVCodec *codec = avcodec_find_decoder(codec_ctx->codec_id);
 178         if (codec == nullptr) {
 179                 fprintf(stderr, "%s: Cannot find decoder\n", pathname.c_str());
 180                 return nullptr;
 181         }
 182         if (avcodec_open2(codec_ctx, codec, nullptr) < 0) {
 183                 fprintf(stderr, "%s: Cannot open decoder\n", pathname.c_str());
 184                 return nullptr;
 185         }
 186         unique_ptr<AVCodecContext, decltype(avcodec_close)*> codec_ctx_cleanup(
 187                 codec_ctx, avcodec_close);
 188
 189         // Read packets until we have a frame or there are none left.
 190         int frame_finished = 0;
 191         auto frame = av_frame_alloc_unique();
 192         do {
 193                 AVPacket pkt;
 194                 unique_ptr<AVPacket, decltype(av_packet_unref)*> pkt_cleanup(
 195                         &pkt, av_packet_unref);
 196                 av_init_packet(&pkt);
 197                 pkt.data = nullptr;
 198                 pkt.size = 0;
 199                 if (av_read_frame(format_ctx.get(), &pkt) < 0) {
 200                         break;
 201                 }
 202                 if (pkt.stream_index != stream_index) {
 203                         continue;
 204                 }
 205
 206                 if (avcodec_decode_video2(codec_ctx, frame.get(), &frame_finished, &pkt) < 0) {
 207                         fprintf(stderr, "%s: Cannot decode frame\n", pathname.c_str());
 208                         return nullptr;
 209                 }
 210         } while (!frame_finished);
 211
 212         // See if there's a cached frame for us.
 213         if (!frame_finished) {
 214                 AVPacket pkt;
 215                 pkt.data = nullptr;
 216                 pkt.size = 0;
 217                 if (avcodec_decode_video2(codec_ctx, frame.get(), &frame_finished, &pkt) < 0) {
 218                         fprintf(stderr, "%s: Cannot decode frame\n", pathname.c_str());
 219                         return nullptr;
 220                 }
 221         }
 222         if (!frame_finished) {
 223                 fprintf(stderr, "%s: Decoder did not output frame.\n", pathname.c_str());
 224                 return nullptr;
 225         }
 226
 227         // TODO: Scale down if needed!
 228         uint8_t *pic_data[4] = {nullptr};
 229         unique_ptr<uint8_t *, decltype(av_freep)*> pic_data_cleanup(
 230                 &pic_data[0], av_freep);
 231         int linesizes[4];
 232         if (av_image_alloc(pic_data, linesizes, frame->width, frame->height, AV_PIX_FMT_RGBA, 1) < 0) {
 233                 fprintf(stderr, "%s: Could not allocate picture data\n", pathname.c_str());
 234                 return nullptr;
 235         }
 236         unique_ptr<SwsContext, decltype(sws_freeContext)*> sws_ctx(
 237                 sws_getContext(frame->width, frame->height,
 238                         (AVPixelFormat)frame->format, frame->width, frame->height,
 239                         AV_PIX_FMT_RGBA, SWS_BICUBIC, nullptr, nullptr, nullptr),
 240                 sws_freeContext);
 241         if (sws_ctx == nullptr) {
 242                 fprintf(stderr, "%s: Could not create scaler context\n", pathname.c_str());
 243                 return nullptr;
 244         }
 245         sws_scale(sws_ctx.get(), frame->data, frame->linesize, 0, frame->height, pic_data, linesizes);
 246
 247         size_t len = frame->width * frame->height * 4;
 248         unique_ptr<uint8_t[]> image_data(new uint8_t[len]);
 249         av_image_copy_to_buffer(image_data.get(), len, pic_data, linesizes, AV_PIX_FMT_RGBA, frame->width, frame->height, 1);
 250
 251         shared_ptr<Image> image(new Image{move(image_data), last_modified});
 252         return image;
 253 }
 254
 255 // Fire up a thread to update the image every second.
 256 // We could do inotify, but this is good enough for now.
 257 void ImageInput::update_thread_func(const std::string &pathname, const timespec &first_modified)
 258 {
 259         timespec last_modified = first_modified;
 260         struct stat buf;
 261         for ( ;; ) {
 262                 sleep(1);
 263
 264                 if (threads_should_quit) {
 265                         return;
 266                 }
 267
 268                 if (stat(pathname.c_str(), &buf) != 0) {
 269                         fprintf(stderr, "%s: Couldn't check for new version, leaving the old in place.\n", pathname.c_str());
 270                         continue;
 271                 }
 272                 if (buf.st_mtim.tv_sec == last_modified.tv_sec &&
 273                     buf.st_mtim.tv_nsec == last_modified.tv_nsec) {
 274                         // Not changed.
 275                         continue;
 276                 }
 277                 shared_ptr<const Image> image = load_image_raw(pathname);
 278                 if (image == nullptr) {
 279                         fprintf(stderr, "Couldn't load image, leaving the old in place.\n");
 280                         continue;
 281                 }
 282                 fprintf(stderr, "Loaded new version of %s from disk.\n", pathname.c_str());
 283                 unique_lock<mutex> lock(all_images_lock);
 284                 all_images[pathname] = image;
 285                 last_modified = image->last_modified;
 286         }
 287 }
 288
 289 void ImageInput::shutdown_updaters()
 290 {
 291         // TODO: Kick these out of the sleep before one second?
 292         threads_should_quit = true;
 293
 294         for (auto &it : update_threads) {
 295                 it.second.join();
 296         }
 297 }
 298
 299 mutex ImageInput::all_images_lock;
 300 map<string, shared_ptr<const ImageInput::Image>> ImageInput::all_images;
 301 map<string, thread> ImageInput::update_threads;
 302 volatile bool ImageInput::threads_should_quit = false;