X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=image_input.cpp;h=2bf4a237bb86758f92cbdcfba808c514c7c19b82;hb=fa54f2630c56a1df0046923d6a77b1bd58abf240;hp=5c1bd8f1f536e5b561c5eb1cee4d7ef26a071e97;hpb=5bb5f8f8854d2f1f2afad0255d32394c3412882a;p=nageru diff --git a/image_input.cpp b/image_input.cpp index 5c1bd8f..2bf4a23 100644 --- a/image_input.cpp +++ b/image_input.cpp @@ -1,34 +1,56 @@ #include "image_input.h" +#include +#include #include +#include +#include +#include +#include extern "C" { #include #include +#include +#include +#include #include +#include #include #include } -#include +#include #include #include - +#include +#include #include #include +#include +#include + +#include "ffmpeg_raii.h" +#include "ffmpeg_util.h" +#include "flags.h" + +struct SwsContext; using namespace std; 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), // Resolution will be overwritten. filename(filename), - current_image(load_image(filename)) + pathname(search_for_file_or_die(filename)), + current_image(load_image(filename, pathname)) { - if (current_image == nullptr) { + if (current_image == nullptr) { // Could happen even though search_for_file() returned. fprintf(stderr, "Couldn't load image, exiting.\n"); exit(1); } + set_width(current_image->width); + set_height(current_image->height); set_pixel_data(current_image->pixels.get()); } @@ -42,119 +64,80 @@ void ImageInput::set_gl_state(GLuint glsl_program_num, const string& prefix, uns // is mostly there to save startup time, not RAM). { unique_lock lock(all_images_lock); - if (all_images[filename] != current_image) { - current_image = all_images[filename]; + 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 &filename) +shared_ptr ImageInput::load_image(const string &filename, const string &pathname) { unique_lock lock(all_images_lock); // Held also during loading. - if (all_images.count(filename)) { - return all_images[filename]; + if (all_images.count(pathname)) { + return all_images[pathname]; } - all_images[filename] = load_image_raw(filename); - timespec first_modified = all_images[filename]->last_modified; - update_threads[filename] = - thread(bind(update_thread_func, filename, first_modified)); - - return all_images[filename]; -} - -// Some helpers to make RAII versions of FFmpeg objects. -// The cleanup functions don't interact all that well with unique_ptr, -// so things get a bit messy and verbose, but overall it's worth it to ensure -// we never leak things by accident in error paths. + all_images[pathname] = load_image_raw(pathname); + timespec first_modified = all_images[pathname]->last_modified; + update_threads[pathname] = + thread(bind(update_thread_func, filename, pathname, first_modified)); -namespace { - -void avformat_close_input_unique(AVFormatContext *format_ctx) -{ - avformat_close_input(&format_ctx); -} - -unique_ptr -avformat_open_input_unique(const char *filename, - AVInputFormat *fmt, AVDictionary **options) -{ - AVFormatContext *format_ctx = nullptr; - if (avformat_open_input(&format_ctx, filename, fmt, options) != 0) { - format_ctx = nullptr; - } - return unique_ptr( - format_ctx, avformat_close_input_unique); + return all_images[pathname]; } -void av_frame_free_unique(AVFrame *frame) -{ - av_frame_free(&frame); -} - -unique_ptr -av_frame_alloc_unique() -{ - AVFrame *frame = av_frame_alloc(); - return unique_ptr( - frame, av_frame_free_unique); -} - -} // namespace - -shared_ptr ImageInput::load_image_raw(const string &filename) +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(filename.c_str(), &buf) != 0) { - fprintf(stderr, "%s: Error stat-ing file\n", filename.c_str()); + 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(filename.c_str(), nullptr, nullptr); + auto format_ctx = avformat_open_input_unique(pathname.c_str(), nullptr, nullptr); if (format_ctx == nullptr) { - fprintf(stderr, "%s: Error opening file\n", filename.c_str()); + 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", filename.c_str()); + 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) { - stream_index = i; - break; - } - } + int stream_index = find_stream_index(format_ctx.get(), AVMEDIA_TYPE_VIDEO); if (stream_index == -1) { - fprintf(stderr, "%s: No video stream found\n", filename.c_str()); + 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()); + 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()); + 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, avcodec_close); + codec_ctx.get(), avcodec_close); // Read packets until we have a frame or there are none left. int frame_finished = 0; - auto frame = av_frame_alloc_unique(); + AVFrameWithDeleter frame = av_frame_alloc_unique(); + bool eof = false; do { AVPacket pkt; unique_ptr pkt_cleanup( @@ -162,41 +145,39 @@ shared_ptr ImageInput::load_image_raw(const string &fil av_init_packet(&pkt); pkt.data = nullptr; pkt.size = 0; - if (av_read_frame(format_ctx.get(), &pkt) < 0) { - break; - } - if (pkt.stream_index != stream_index) { - 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.get(), &frame_finished, &pkt) < 0) { - fprintf(stderr, "%s: Cannot decode frame\n", filename.c_str()); + 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; } - } while (!frame_finished); + } while (!eof); - // See if there's a cached frame for us. - if (!frame_finished) { - AVPacket pkt; - pkt.data = nullptr; - pkt.size = 0; - if (avcodec_decode_video2(codec_ctx, frame.get(), &frame_finished, &pkt) < 0) { - fprintf(stderr, "%s: Cannot decode frame\n", filename.c_str()); - return nullptr; - } - } if (!frame_finished) { - fprintf(stderr, "%s: Decoder did not output frame.\n", filename.c_str()); + fprintf(stderr, "%s: Decoder did not output frame.\n", pathname.c_str()); return nullptr; } - // TODO: Scale down if needed! 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", filename.c_str()); + fprintf(stderr, "%s: Could not allocate picture data\n", pathname.c_str()); return nullptr; } unique_ptr sws_ctx( @@ -205,7 +186,7 @@ shared_ptr ImageInput::load_image_raw(const string &fil 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()); + fprintf(stderr, "%s: Could not create scaler context\n", pathname.c_str()); return nullptr; } sws_scale(sws_ctx.get(), frame->data, frame->linesize, 0, frame->height, pic_data, linesizes); @@ -214,22 +195,32 @@ shared_ptr ImageInput::load_image_raw(const string &fil 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}); + shared_ptr image(new Image{unsigned(frame->width), unsigned(frame->height), 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. -// TODO: These don't really quit, ever. Should they? -void ImageInput::update_thread_func(const std::string &filename, const timespec &first_modified) +void ImageInput::update_thread_func(const std::string &filename, const std::string &pathname, const timespec &first_modified) { + char thread_name[16]; + snprintf(thread_name, sizeof(thread_name), "Update_%s", filename.c_str()); + pthread_setname_np(pthread_self(), thread_name); + timespec last_modified = first_modified; struct stat buf; for ( ;; ) { - sleep(1); + { + unique_lock lock(threads_should_quit_mu); + threads_should_quit_modified.wait_for(lock, chrono::seconds(1), []() { return threads_should_quit; }); + } - if (stat(filename.c_str(), &buf) != 0) { - fprintf(stderr, "%s: Couldn't check for new version, leaving the old in place.\n", filename.c_str()); + 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 && @@ -237,18 +228,33 @@ void ImageInput::update_thread_func(const std::string &filename, const timespec // Not changed. continue; } - shared_ptr image = load_image_raw(filename); + 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", filename.c_str()); + fprintf(stderr, "Loaded new version of %s from disk.\n", pathname.c_str()); unique_lock lock(all_images_lock); - all_images[filename] = image; + all_images[pathname] = image; last_modified = image->last_modified; } } +void ImageInput::shutdown_updaters() +{ + { + unique_lock lock(threads_should_quit_mu); + threads_should_quit = true; + threads_should_quit_modified.notify_all(); + } + for (auto &it : update_threads) { + it.second.join(); + } +} + mutex ImageInput::all_images_lock; map> ImageInput::all_images; map ImageInput::update_threads; +mutex ImageInput::threads_should_quit_mu; +bool ImageInput::threads_should_quit = false; +condition_variable ImageInput::threads_should_quit_modified;