X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=image_input.cpp;h=b8e2b02942b4ea01993131f2ee73acf595479e05;hb=b0d8d860fba68b63b5cd70ef97d81b7146b031ab;hp=090b6db6cf1ba700f7e3b2e1c8bf06e0c010c699;hpb=93f0cd515b3993ac6c6d1be6e639cbf0bf5a902a;p=nageru diff --git a/image_input.cpp b/image_input.cpp index 090b6db..b8e2b02 100644 --- a/image_input.cpp +++ b/image_input.cpp @@ -10,90 +10,260 @@ extern "C" { #include } +#include +#include +#include +#include + +#include +#include + +#include "ffmpeg_raii.h" +#include "flags.h" + using namespace std; -ImageInput::ImageInput(const std::string &filename) +namespace { + +string search_for_file(const string &filename) +{ + // Look for the file in all theme_dirs until we find one; + // that will be the permanent resolution of this file, whether + // it is actually valid or not. + // We store errors from all the attempts, and show them + // once we know we can't find any of them. + vector errors; + for (const string &dir : global_flags.theme_dirs) { + string pathname = dir + "/" + filename; + if (access(pathname.c_str(), O_RDONLY) == 0) { + return pathname; + } else { + char buf[512]; + snprintf(buf, sizeof(buf), "%s: %s", pathname.c_str(), strerror(errno)); + errors.push_back(buf); + } + } + + for (const string &error : errors) { + fprintf(stderr, "%s\n", error.c_str()); + } + fprintf(stderr, "Couldn't find %s in any directory in --theme-dirs, exiting.\n", + filename.c_str()); + exit(1); +} + +} // namespace + +ImageInput::ImageInput(const string &filename) : movit::FlatInput({movit::COLORSPACE_sRGB, movit::GAMMA_sRGB}, movit::FORMAT_RGBA_POSTMULTIPLIED_ALPHA, - GL_UNSIGNED_BYTE, 1280, 720) // FIXME + GL_UNSIGNED_BYTE, 1280, 720), // FIXME + pathname(search_for_file(filename)), + current_image(load_image(pathname)) { - AVFormatContext *format_ctx = nullptr; - if (avformat_open_input(&format_ctx, filename.c_str(), nullptr, nullptr) != 0) { - fprintf(stderr, "%s: Error opening file\n", filename.c_str()); + if (current_image == nullptr) { // Could happen even though search_for_file() returned. + fprintf(stderr, "Couldn't load image, exiting.\n"); exit(1); } + set_pixel_data(current_image->pixels.get()); +} - if (avformat_find_stream_info(format_ctx, nullptr) < 0) { - fprintf(stderr, "%s: Error finding stream info\n", filename.c_str()); - exit(1); +void ImageInput::set_gl_state(GLuint glsl_program_num, const string& prefix, unsigned *sampler_num) +{ + // See if the background thread has given us a new version of our image. + // Note: The old version might still be lying around in other ImageInputs + // (in fact, it's likely), but at least the total amount of memory used + // is bounded. Currently we don't even share textures between them, + // so there's a fair amount of OpenGL memory waste anyway (the cache + // is mostly there to save startup time, not RAM). + { + unique_lock lock(all_images_lock); + if (all_images[pathname] != current_image) { + current_image = all_images[pathname]; + set_pixel_data(current_image->pixels.get()); + } + } + movit::FlatInput::set_gl_state(glsl_program_num, prefix, sampler_num); +} + +shared_ptr ImageInput::load_image(const string &pathname) +{ + unique_lock lock(all_images_lock); // Held also during loading. + if (all_images.count(pathname)) { + return all_images[pathname]; + } + + all_images[pathname] = load_image_raw(pathname); + timespec first_modified = all_images[pathname]->last_modified; + update_threads[pathname] = + thread(bind(update_thread_func, pathname, first_modified)); + + return all_images[pathname]; +} + +shared_ptr ImageInput::load_image_raw(const string &pathname) +{ + // Note: Call before open, not after; otherwise, there's a race. + // (There is now, too, but it tips the correct way. We could use fstat() + // if we had the file descriptor.) + struct stat buf; + if (stat(pathname.c_str(), &buf) != 0) { + fprintf(stderr, "%s: Error stat-ing file\n", pathname.c_str()); + return nullptr; + } + timespec last_modified = buf.st_mtim; + + auto format_ctx = avformat_open_input_unique(pathname.c_str(), nullptr, nullptr); + if (format_ctx == nullptr) { + fprintf(stderr, "%s: Error opening file\n", pathname.c_str()); + return nullptr; + } + + if (avformat_find_stream_info(format_ctx.get(), nullptr) < 0) { + fprintf(stderr, "%s: Error finding stream info\n", pathname.c_str()); + return nullptr; } int stream_index = -1; for (unsigned i = 0; i < format_ctx->nb_streams; ++i) { - if (format_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) { + if (format_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) { stream_index = i; break; } } if (stream_index == -1) { - fprintf(stderr, "%s: No video stream found\n", filename.c_str()); - exit(1); + fprintf(stderr, "%s: No video stream found\n", pathname.c_str()); + return nullptr; } - AVCodecContext *codec_ctx = format_ctx->streams[stream_index]->codec; - AVCodec *codec = avcodec_find_decoder(codec_ctx->codec_id); + const AVCodecParameters *codecpar = format_ctx->streams[stream_index]->codecpar; + AVCodecContextWithDeleter codec_ctx = avcodec_alloc_context3_unique(nullptr); + if (avcodec_parameters_to_context(codec_ctx.get(), codecpar) < 0) { + fprintf(stderr, "%s: Cannot fill codec parameters\n", pathname.c_str()); + return nullptr; + } + AVCodec *codec = avcodec_find_decoder(codecpar->codec_id); if (codec == nullptr) { - fprintf(stderr, "%s: Cannot find decoder\n", filename.c_str()); - exit(1); + fprintf(stderr, "%s: Cannot find decoder\n", pathname.c_str()); + return nullptr; } - if (avcodec_open2(codec_ctx, codec, nullptr) < 0) { - fprintf(stderr, "%s: Cannot open decoder\n", filename.c_str()); - exit(1); + if (avcodec_open2(codec_ctx.get(), codec, nullptr) < 0) { + fprintf(stderr, "%s: Cannot open decoder\n", pathname.c_str()); + return nullptr; } + unique_ptr codec_ctx_cleanup( + codec_ctx.get(), avcodec_close); - // Read packets until we have a frame. + // Read packets until we have a frame or there are none left. int frame_finished = 0; - AVFrame *frame = av_frame_alloc(); + AVFrameWithDeleter frame = av_frame_alloc_unique(); + bool eof = false; do { AVPacket pkt; + unique_ptr pkt_cleanup( + &pkt, av_packet_unref); av_init_packet(&pkt); pkt.data = nullptr; pkt.size = 0; - if (av_read_frame(format_ctx, &pkt) < 0) { - fprintf(stderr, "%s: Cannot read frame\n", filename.c_str()); - exit(1); - } - if (pkt.stream_index != stream_index) { - av_free_packet(&pkt); - continue; + if (av_read_frame(format_ctx.get(), &pkt) == 0) { + if (pkt.stream_index != stream_index) { + continue; + } + if (avcodec_send_packet(codec_ctx.get(), &pkt) < 0) { + fprintf(stderr, "%s: Cannot send packet to codec.\n", pathname.c_str()); + return nullptr; + } + } else { + eof = true; // Or error, but ignore that for the time being. } - if (avcodec_decode_video2(codec_ctx, frame, &frame_finished, &pkt) < 0) { - fprintf(stderr, "%s: Cannot decode frame\n", filename.c_str()); - exit(1); + int err = avcodec_receive_frame(codec_ctx.get(), frame.get()); + if (err == 0) { + frame_finished = true; + break; + } else if (err != AVERROR(EAGAIN)) { + fprintf(stderr, "%s: Cannot receive frame from codec.\n", pathname.c_str()); + return nullptr; } - av_free_packet(&pkt); - } while (!frame_finished); + } while (!eof); + + if (!frame_finished) { + fprintf(stderr, "%s: Decoder did not output frame.\n", pathname.c_str()); + return nullptr; + } // TODO: Scale down if needed! - AVPicture pic; - avpicture_alloc(&pic, PIX_FMT_RGBA, frame->width, frame->height); - SwsContext *sws_ctx = sws_getContext(frame->width, frame->height, - (PixelFormat)frame->format, frame->width, frame->height, - PIX_FMT_RGBA, SWS_BICUBIC, nullptr, nullptr, nullptr); + uint8_t *pic_data[4] = {nullptr}; + unique_ptr pic_data_cleanup( + &pic_data[0], av_freep); + int linesizes[4]; + if (av_image_alloc(pic_data, linesizes, frame->width, frame->height, AV_PIX_FMT_RGBA, 1) < 0) { + fprintf(stderr, "%s: Could not allocate picture data\n", pathname.c_str()); + return nullptr; + } + unique_ptr sws_ctx( + sws_getContext(frame->width, frame->height, + (AVPixelFormat)frame->format, frame->width, frame->height, + AV_PIX_FMT_RGBA, SWS_BICUBIC, nullptr, nullptr, nullptr), + sws_freeContext); if (sws_ctx == nullptr) { - fprintf(stderr, "%s: Could not create scaler context\n", filename.c_str()); - exit(1); + fprintf(stderr, "%s: Could not create scaler context\n", pathname.c_str()); + return nullptr; } - sws_scale(sws_ctx, frame->data, frame->linesize, 0, frame->height, pic.data, pic.linesize); - sws_freeContext(sws_ctx); + sws_scale(sws_ctx.get(), frame->data, frame->linesize, 0, frame->height, pic_data, linesizes); size_t len = frame->width * frame->height * 4; - image_data.reset(new uint8_t[len]); - av_image_copy_to_buffer(image_data.get(), len, pic.data, pic.linesize, PIX_FMT_RGBA, frame->width, frame->height, 1); - set_pixel_data(image_data.get()); - - avpicture_free(&pic); - av_frame_free(&frame); - avcodec_close(codec_ctx); - avformat_close_input(&format_ctx); + unique_ptr image_data(new uint8_t[len]); + av_image_copy_to_buffer(image_data.get(), len, pic_data, linesizes, AV_PIX_FMT_RGBA, frame->width, frame->height, 1); + + shared_ptr image(new Image{move(image_data), last_modified}); + return image; +} + +// Fire up a thread to update the image every second. +// We could do inotify, but this is good enough for now. +void ImageInput::update_thread_func(const std::string &pathname, const timespec &first_modified) +{ + timespec last_modified = first_modified; + struct stat buf; + for ( ;; ) { + sleep(1); + + if (threads_should_quit) { + return; + } + + if (stat(pathname.c_str(), &buf) != 0) { + fprintf(stderr, "%s: Couldn't check for new version, leaving the old in place.\n", pathname.c_str()); + continue; + } + if (buf.st_mtim.tv_sec == last_modified.tv_sec && + buf.st_mtim.tv_nsec == last_modified.tv_nsec) { + // Not changed. + continue; + } + shared_ptr image = load_image_raw(pathname); + if (image == nullptr) { + fprintf(stderr, "Couldn't load image, leaving the old in place.\n"); + continue; + } + fprintf(stderr, "Loaded new version of %s from disk.\n", pathname.c_str()); + unique_lock lock(all_images_lock); + all_images[pathname] = image; + last_modified = image->last_modified; + } } + +void ImageInput::shutdown_updaters() +{ + // TODO: Kick these out of the sleep before one second? + threads_should_quit = true; + + for (auto &it : update_threads) { + it.second.join(); + } +} + +mutex ImageInput::all_images_lock; +map> ImageInput::all_images; +map ImageInput::update_threads; +volatile bool ImageInput::threads_should_quit = false;