th_movie.h

Go to the documentation of this file.

/*
Copyright (c) 2012 Stephen Baker
 
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
 
#ifndef TH_VIDEO_H
#define TH_VIDEO_H
 
#include "config.h"
 
#include <SDL_rect.h>
#include <SDL_render.h>
 
#include <array>
#include <atomic>
#include <condition_variable>
#include <memory>
#include <mutex>
#include <queue>
#include <string>
#include <thread>
 
#ifdef CORSIX_TH_USE_FFMPEG
#include <SDL_mixer.h>
 
extern "C" {
#ifndef INT64_C
#define INT64_C(c) (c##LL)
#define UINT64_C(c) (c##ULL)
#endif
#include <libavcodec/avcodec.h>
// IWYU pragma: no_include <libavcodec/codec.h>
// IWYU pragma: no_include <libavcodec/packet.h>
// IWYU pragma: no_include <libavcodec/version.h>
#include <libavformat/avformat.h>
#include <libavutil/avutil.h>  // IWYU pragma: keep
// IWYU pragma: no_include <libavutil/channel_layout.h>
// IWYU pragma: no_include <libavutil/frame.h>
// IWYU pragma: no_include <libavutil/mem.h>
// IWYU pragma: no_include <libavutil/pixfmt.h>
// IWYU pragma: no_include <libavutil/version.h>
#include <libswresample/swresample.h>
}
 
struct SwsContext;
 
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(59, 0, 100)
using av_codec_ptr = AVCodec*;
#else
using av_codec_ptr = const AVCodec*;
#endif
 
class av_packet_deleter {
 public:
  void operator()(AVPacket* p) {
    av_packet_unref(p);
    av_free(p);
  }
};
 
using av_packet_unique_ptr = std::unique_ptr<AVPacket, av_packet_deleter>;
 
class av_frame_deleter {
 public:
  void operator()(AVFrame* f) { av_frame_free(&f); }
};
 
using av_frame_unique_ptr = std::unique_ptr<AVFrame, av_frame_deleter>;
 
class av_codec_context_deleter {
 public:
  void operator()(AVCodecContext* c) { avcodec_free_context(&c); }
};
 
using av_codec_context_unique_ptr =
    std::unique_ptr<AVCodecContext, av_codec_context_deleter>;
 
class mix_chunk_deleter {
 public:
  void operator()(Mix_Chunk* c) { Mix_FreeChunk(c); }
};
 
using mix_chunk_unique_ptr = std::unique_ptr<Mix_Chunk, mix_chunk_deleter>;
 
#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(57, 24, 100)
class av_channel_layout_deleter {
 public:
  void operator()(AVChannelLayout* c) {
    av_channel_layout_uninit(c);
    delete c;
  }
};
 
using av_channel_layout_unique_ptr =
    std::unique_ptr<AVChannelLayout, av_channel_layout_deleter>;
#endif
 
class movie_picture {
 public:
  movie_picture();
  ~movie_picture();
 
  void allocate(int iWidth, int iHeight);
 
  void deallocate();
 
  uint8_t* buffer;                   
  const AVPixelFormat pixel_format;  
  int width;                         
  int height;                        
  double pts;                        
  std::mutex mutex;                  
};
 
class movie_picture_buffer {
 public:
  movie_picture_buffer();
  ~movie_picture_buffer();
 
  // NB: The following functions are called by the main program thread
 
  void abort();
 
  void reset();
 
  void allocate(SDL_Renderer* pRenderer, int iWidth, int iHeight);
 
  void deallocate();
 
  bool advance();
 
  void draw(SDL_Renderer* pRenderer, const SDL_Rect& dstrect);
 
  double get_next_pts();
 
  bool empty();
 
  // NB: These functions are called by a second thread
 
  bool full();
 
  int write(AVFrame* pFrame, double dPts);
 
 private:
  bool unsafe_full() const;
 
  static constexpr std::size_t picture_buffer_size = 4;
 
  std::atomic<bool> aborting;
 
  bool allocated;
 
  int picture_count;
 
  std::size_t read_index;
 
  std::size_t write_index;
 
  SwsContext* sws_context;
 
  SDL_Texture* texture;
 
  std::mutex mutex;
 
  std::condition_variable cond;
 
  std::array<movie_picture, picture_buffer_size> picture_queue;
};
 
class av_packet_queue {
 public:
  av_packet_queue();
 
  ~av_packet_queue() = default;
 
  void push(av_packet_unique_ptr packet);
 
  av_packet_unique_ptr pull(bool block);
 
  std::size_t get_count() const;
 
  void release();
 
  void clear();
 
 private:
  std::queue<av_packet_unique_ptr> data;  
  std::mutex mutex;  
  std::condition_variable
      cond;  
};
#endif  // CORSIX_TH_USE_FFMPEG
 
class movie_player {
 public:
  movie_player();
 
  ~movie_player();
 
  void set_renderer(SDL_Renderer* pRenderer);
 
  bool movies_enabled() const;
 
  bool load(const char* szFilepath);
 
  void unload();
 
  void play(int requested_audio_channel);
 
  void stop();
 
  void togglePause();
 
  int get_native_height() const;
 
  int get_native_width() const;
 
  bool has_audio_track() const;
 
  double get_movie_length() const;
 
  const char* get_last_error() const;
 
  void clear_last_error();
 
  double refresh(const SDL_Rect& destination_rect);
 
  void deallocate_picture_buffer();
 
  void allocate_picture_buffer();
 
  void read_streams();
 
  void run_video();
 
  void copy_audio_to_stream(uint8_t* pbStream, int iStreamSize);
 
 private:
#ifdef CORSIX_TH_USE_FFMPEG
  static constexpr size_t movie_error_buffer_capacity =
      128;  
 
  av_codec_context_unique_ptr get_codec_context_for_stream(
      av_codec_ptr codec, AVStream* stream) const;
 
  void play_audio(int requested_audio_channel);
 
  double get_presentation_time_for_frame(const AVFrame& frame,
                                         int streamIndex) const;
 
  int decode_audio_frame(uint8_t* stream, int stream_size);
 
  int populate_frame(int stream, AVFrame& frame);
 
  int populate_frame(AVCodecContext& ctx, av_packet_queue& pq, AVFrame& frame);
 
  SDL_Renderer* renderer;  
 
  std::string last_error;
 
  char error_buffer[movie_error_buffer_capacity];
 
  std::atomic<bool> aborting;
 
  std::atomic<bool> paused{};
  uint32_t pause_start_time{};  
 
  std::mutex decoding_audio_mutex;  
 
  AVFormatContext* format_context;  
  int video_stream_index;           
  int audio_stream_index;           
  av_codec_context_unique_ptr
      video_codec_context;  
  av_codec_context_unique_ptr
      audio_codec_context;  
 
  // queues for transferring data between threads
  av_packet_queue video_queue;  
  av_packet_queue audio_queue;  
  ::movie_picture_buffer movie_picture_buffer;  
 
  // clock sync parameters
  std::uint32_t current_sync_pts_system_time;  
  double current_sync_pts;  
 
  SwrContext* audio_resample_context;  
 
  mix_chunk_unique_ptr empty_audio_chunk;  
  std::array<std::uint8_t, 1024>
      audio_chunk_buffer;  
 
  int audio_channel;    
  int mixer_channels;   
  int mixer_frequency;  
 
  std::thread stream_thread;  
  std::thread video_thread;   
#endif                        // CORSIX_TH_USE_FFMPEG
};
 
#endif  // TH_VIDEO_H