/**
 * PANDA 3D SOFTWARE
 * Copyright (c) Carnegie Mellon University.  All rights reserved.
 *
 * All use of this software is subject to the terms of the revised BSD
 * license.  You should have received a copy of this license along
 * with this source code in a file named "LICENSE."
 *
 * @file ffmpegVideoCursor.h
 * @author jyelon
 * @date 2007-08-01
 */

#ifndef FFMPEGVIDEOCURSOR_H
#define FFMPEGVIDEOCURSOR_H

#include "pandabase.h"
#include "movieVideoCursor.h"
#include "texture.h"
#include "pointerTo.h"
#include "ffmpegVirtualFile.h"
#include "genericThread.h"
#include "threadPriority.h"
#include "pmutex.h"
#include "reMutex.h"
#include "conditionVar.h"
#include "pdeque.h"

class FfmpegVideo;
struct AVFormatContext;
struct AVCodecContext;
struct AVStream;
struct AVPacket;
struct AVFrame;
struct SwsContext;

/**
 *
 */
class EXPCL_FFMPEG FfmpegVideoCursor : public MovieVideoCursor {
private:
  FfmpegVideoCursor();
  void init_from(FfmpegVideo *src);

PUBLISHED:
  FfmpegVideoCursor(FfmpegVideo *src);
  virtual ~FfmpegVideoCursor();

  void set_max_readahead_frames(int max_readahead_frames);
  int get_max_readahead_frames() const;

  void set_thread_priority(ThreadPriority thread_priority);
  ThreadPriority get_thread_priority() const;

  void start_thread();
  BLOCKING void stop_thread();
  bool is_thread_started() const;

public:
  virtual bool set_time(double timestamp, int loop_count);
  virtual PT(Buffer) fetch_buffer();

public:
  // Nested class must be public for PT(FfmpegBuffer) to work correctly.
  class EXPCL_FFMPEG FfmpegBuffer : public Buffer {
  public:
    ALLOC_DELETED_CHAIN(FfmpegBuffer);
    INLINE FfmpegBuffer(size_t block_size, double video_timebase);
    virtual int compare_timestamp(const Buffer *other) const;
    virtual double get_timestamp() const;

    int _begin_frame;
    int _end_frame;
    double _video_timebase;

  public:
    static TypeHandle get_class_type() {
      return _type_handle;
    }
    static void init_type() {
      Buffer::init_type();
      register_type(_type_handle, "FfmpegVideoCursor::FfmpegBuffer",
                    Buffer::get_class_type());
    }
    virtual TypeHandle get_type() const {
      return get_class_type();
    }
    virtual TypeHandle force_init_type() {init_type(); return get_class_type();}

  private:
    static TypeHandle _type_handle;
  };

protected:
  virtual PT(Buffer) make_new_buffer();

private:
  bool open_stream();
  void close_stream();
  void cleanup();

  Filename _filename;
  std::string _sync_name;
  int _max_readahead_frames;
  ThreadPriority _thread_priority;
  PT(GenericThread) _thread;

  int _pixel_format;

  // This global Mutex protects calls to avcodec_opencloseetc.
  static ReMutex _av_lock;

  // Protects _readahead_frames and all the immediately following members.
  Mutex _lock;

  // Condition: the thread has something to do.
  ConditionVar _action_cvar;

  typedef pdeque<PT(FfmpegBuffer) > Buffers;
  Buffers _readahead_frames;
  enum ThreadStatus {
    TS_stopped,
    TS_wait,
    TS_readahead,
    TS_seek,
    TS_seeking,
    TS_shutdown,
  };
  ThreadStatus _thread_status;
  int _seek_frame;

  int _current_frame;
  PT(FfmpegBuffer) _current_frame_buffer;

private:
  // The following functions will be called in the sub-thread.
  static void st_thread_main(void *self);
  void thread_main();
  bool do_poll();

  PT(FfmpegBuffer) do_alloc_frame();
  void do_clear_all_frames();

  bool fetch_packet(int default_frame);
  bool do_fetch_packet(int default_frame);
  void fetch_frame(int frame);
  void decode_frame(int &finished);
  void do_decode_frame(int &finished);
  void seek(int frame, bool backward);
  void do_seek(int frame, bool backward);
  int binary_seek(int min_frame, int max_frame, int target_frame, int num_iterations);
  void advance_to_frame(int frame);
  void reset_stream();
  void export_frame(FfmpegBuffer *buffer);

  // The following data members will be accessed by the sub-thread.
  AVPacket *_packet;
  int _packet_frame;
  AVFormatContext *_format_ctx;
  AVCodecContext *_video_ctx;
  SwsContext *_convert_ctx;

  FfmpegVirtualFile _ffvfile;
  int _video_index;
  double _video_timebase;
  AVFrame *_frame;
  AVFrame *_frame_out;
  int _initial_dts;
  double _min_fseek;
  int _begin_frame;
  int _end_frame;
  bool _frame_ready;
  bool _eof_known;
  int _eof_frame;

  // PStat collectors.
  static PStatCollector _fetch_buffer_pcollector;
  static PStatCollector _seek_pcollector;
  static PStatCollector _export_frame_pcollector;

public:
  static void register_with_read_factory();
  virtual void write_datagram(BamWriter *manager, Datagram &dg);

  virtual void finalize(BamReader *manager);

protected:
  static TypedWritable *make_from_bam(const FactoryParams &params);
  void fillin(DatagramIterator &scan, BamReader *manager);

public:
  static TypeHandle get_class_type() {
    return _type_handle;
  }
  static void init_type() {
    MovieVideoCursor::init_type();
    register_type(_type_handle, "FfmpegVideoCursor",
                  MovieVideoCursor::get_class_type());
    FfmpegBuffer::init_type();
  }
  virtual TypeHandle get_type() const {
    return get_class_type();
  }
  virtual TypeHandle force_init_type() {init_type(); return get_class_type();}

private:
  static TypeHandle _type_handle;

  friend class FfmpegVideo;
};

#include "ffmpegVideoCursor.I"

#endif // FFMPEGVIDEO_H