#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavutil/avutil.h>

#include <libavutil/channel_layout.h>

#include <libavutil/mathematics.h>

#include <libavutil/timestamp.h>

#include <libavutil/opt.h>

#include <libswscale/swscale.h>

#include <chrono>

#define END_FRAME -1

#define NULL_FRAME 0 //could be metadata frame

#define AUDIO_FRAME 1

#define VIDEO_FRAME 2

static jboolean ffmpeg_loaded = JNI_FALSE;

static jboolean ff_debug_log = JNI_FALSE;

static jboolean ff_debug_trace = JNI_FALSE;

static jboolean ff_debug_buffer = JNI_FALSE;

static jboolean ff_debug_box = JNI_FALSE;

static jboolean ff_debug_time_base = JNI_FALSE;

JF_LIB_HANDLE codec = NULL;

JF_LIB_HANDLE device = NULL;

JF_LIB_HANDLE ffilter = NULL;

JF_LIB_HANDLE format = NULL;

JF_LIB_HANDLE util = NULL;

JF_LIB_HANDLE resample = NULL;

JF_LIB_HANDLE postproc = NULL;

JF_LIB_HANDLE scale = NULL;

jboolean shownCopyWarning = JNI_FALSE;

static AVChannelLayout channel_layout_1;

static AVChannelLayout channel_layout_2;

static AVChannelLayout channel_layout_4;

static void copyWarning() {

printf("Warning : JNI::Get*ArrayElements returned a copy : Performance will be degraded!\n");

shownCopyWarning = JNI_TRUE;

}

AVCodec* (*_avcodec_find_decoder)(int codec_id);

int (*_avcodec_open2)(AVCodecContext *avctx,AVCodec *codec,void* options);

AVCodecContext* (*_avcodec_alloc_context3)(AVCodec *codec);

void (*_avcodec_free_context)(AVCodecContext **ctx);

void (*_av_init_packet)(AVPacket *pkt);

void (*_av_packet_free)(AVPacket **pkt);

void (*_av_packet_free_side_data)(AVPacket *pkt);

AVCodec* (*_avcodec_find_encoder)(int codec_id);

int (*_avcodec_fill_audio_frame)(AVFrame *frame, int nb_channels, int fmt, void* buf, int bufsize, int align);

const char* (*_avcodec_get_name)(AVCodecID id);

void (*_av_packet_rescale_ts)(AVPacket *pkt, AVRational src, AVRational dst);

int (*_avcodec_parameters_to_context)(AVCodecContext *ctx, const AVCodecParameters *par);

int (*_avcodec_parameters_from_context)(AVCodecParameters *par, const AVCodecContext *ctx);

int (*_avcodec_version)();

int (*_avcodec_send_frame)(AVCodecContext *ctx, const AVFrame *frame);

int (*_avcodec_receive_packet)(AVCodecContext *ctx, const AVPacket *pkt);

int (*_avcodec_send_packet)(AVCodecContext *ctx, const AVPacket *pkt);

int (*_avcodec_receive_frame)(AVCodecContext *ctx, const AVFrame *frame);

AVOutputFormat* (*_av_guess_format)(const char* shortName, const char* fileName, const char* mimeType);

int (*_av_find_best_stream)(AVFormatContext *ic,int type,int wanted_stream_nb,int related_stream

,void** decoder_ret, int flags);

AVIOContext* (*_avio_alloc_context)(void* buffer,int buffer_size,int write_flag,void* opaque

,void* read,void* write,void* seek);

AVFormatContext* (*_avformat_alloc_context)();

int (*_avformat_alloc_output_context2)(AVFormatContext** fmt_ctx, AVOutputFormat* ofmt, const char* name, const char* filename);

int (*_avio_close)(void* ctx);

void (*_avformat_free_context)(AVFormatContext *s);

int (*_avformat_open_input)(void** ps,const char* filename,void* fmt,void* options);

int (*_avformat_find_stream_info)(AVFormatContext *ic,void** options);

int (*_av_read_frame)(AVFormatContext *s,AVPacket *pkt);

void* (*_av_find_input_format)(const char* name);

int (*_avformat_seek_file)(AVFormatContext *ctx, int stream_idx, int64_t min_ts, int64_t ts, int64_t max_ts, int flags);

int (*_av_seek_frame)(AVFormatContext *ctx, int stream_idx, int64_t ts, int flags);

AVStream* (*_avformat_new_stream)(AVFormatContext *fc, AVCodec *codec);

int (*_avformat_write_header)(AVFormatContext *fc, void* opts);

int (*_av_interleaved_write_frame)(AVFormatContext *fc, AVPacket *pkt);

int (*_av_write_frame)(AVFormatContext *fc, AVPacket *pkt);

int (*_avio_flush)(void* io_ctx);

void (*_av_dump_format)(AVFormatContext *fmt_ctx, int index, const char* url, int is_output);

int (*_av_write_trailer)(AVFormatContext *fc);

int (*_avformat_version)();

void (*_av_image_copy)(uint8_t* dst_data[],int dst_linesizes[]

, uint8_t* src_data[],int src_linesizes[],int pix_fmt,int width,int height);

int (*_av_get_bytes_per_sample)(int sample_fmt);

void* (*_av_malloc)(int size);

void* (*_av_mallocz)(int size);

void (*_av_free)(void* ptr);

void (*_av_freep)(void** ptr);

int (*_av_image_alloc)(uint8_t* ptrs[],int linesizes[],int w,int h,int pix_fmt,int align);

int (*_av_opt_set)(void* obj,const char* name,const char* val,int search_flags);

int (*_av_opt_set_int)(void* obj,const char* name,int64_t val,int search_flags);

int (*_av_opt_set_sample_fmt)(void* obj,const char* name,int val,int search_flags);

int (*_av_opt_get)(void* obj,const char* name,int search_flags,void* val[]);

int (*_av_opt_get_int)(void* obj,const char* name,int search_flags,int64_t val[]);

void* (*_av_opt_find)(void* obj, const char* name, const char* unit, int opt_flags, int search_flags);

void* (*_av_opt_next)(void* obj, void* prev);

void* (*_av_opt_child_next)(void* obj, void* prev);

void (*_av_opt_set_defaults)(void* obj);

int64_t (*_av_rescale_rnd)(int64_t a,int64_t b,int64_t c,AVRounding r);

int (*_av_samples_alloc)(uint8_t* audio_data[],int linesize[],int nb_channels,int nb_samples,int sample_fmt,int align);

int64_t (*_av_rescale_q)(int64_t a, AVRational bq, AVRational cq);

int (*_av_samples_get_buffer_size)(void* linesize, int chs, int samples, int sample_fmt, int align);

int (*_av_log_set_level)(int lvl);

void* (*_av_dict_get)(AVDictionary* dict, const char* key, void* prev, int flags);

int (*_av_dict_set)(AVDictionary** dictref, const char* key, const char* value, int flags);

int (*_av_frame_make_writable)(AVFrame *frame);

int (*_av_compare_ts)(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b);

int (*_av_frame_get_buffer)(AVFrame *frame, int align);

AVFrame* (*_av_frame_alloc)();

void (*_av_frame_free)(void** frame);

void (*_av_buffer_unref)(AVBufferRef **buf);

int (*_av_channel_layout_copy) (AVChannelLayout* dst, const AVChannelLayout* src);

int (*_avutil_version)();

void* (*_swr_alloc)();

int (*_swr_alloc_set_opts2)(void**, AVChannelLayout* out_ch_layout, int out_sample_fmt, int out_sample_rate, AVChannelLayout* in_ch_layout, int in_sample_fmt, int in_sample_rate, int log_offset, void*log_ctx);

int (*_swr_init)(void* ctx);

int64_t (*_swr_get_delay)(void* ctx,int64_t base);

int (*_swr_convert)(void* ctx,uint8_t* out_arg[],int out_count,uint8_t* in_arg[],int in_count);

void (*_swr_free)(void** ctx);

void* (*_sws_getContext)(int srcW,int srcH,int srcFormat,int dstW,int dstH,int dstFormat

,int flags,void* srcFilter,void* dstFilter, void* param);

int (*_sws_scale)(void* c, uint8_t* srcSlice[],int srcStride[],int srcSliceY,int srcSliceH

,uint8_t* dst[],int dstStride[]);

void (*_sws_freeContext)(void* ctx);

static AVPacket *AVPacket_New() {

AVPacket *pkt = (AVPacket*)(*_av_mallocz)(sizeof(AVPacket));

return pkt;

}

static AVOutputFormat *AVOutputFormat_New() {

AVOutputFormat *ofmt = (AVOutputFormat*)(*_av_mallocz)(sizeof(AVOutputFormat));

return ofmt;

}

static AVOutputFormat *vpx = NULL;

static void _av_free_packet(AVPacket *pkt) {

}

static void log_packet(const char* type, const AVFormatContext *fmt_ctx, const AVPacket *pkt)

}

#ifndef _WIN32

int GetLastError() {

return errno;

}

#endif

static int64_t currentTimeMillis() {

return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();

}

static jboolean ffmpeg_init(const char* codecFile, const char* deviceFile, const char* filterFile, const char* formatFile

}

JNIEXPORT jboolean JNICALL Java_javaforce_media_MediaCoder_ninit

}

JNIEXPORT void JNICALL Java_javaforce_media_MediaCoder_setLogging

}

static int ff_min(int a, int b) {

if (a < b) return a; else return b;

}

struct FFContext {

};

#define ffiobufsiz (64 * 1024)

FFContext* createFFContext(JNIEnv *e, jobject c) {

FFContext *ctx;

jclass cls_coder = e->FindClass("javaforce/media/MediaCoder");

jfieldID fid_ff_ctx = e->GetFieldID(cls_coder, "ctx", "J");

ctx = (FFContext*)e->GetLongField(c, fid_ff_ctx);

if (ctx != NULL) {

printf("MediaCoder used twice\n");

return NULL;

}

ctx = (FFContext*)(*_av_mallocz)(sizeof(FFContext));

e->SetLongField(c,fid_ff_ctx,(jlong)ctx);

ctx->e = e;

ctx->c = c;

return ctx;

}

FFContext* getFFContext(JNIEnv *e, jobject c) {

FFContext *ctx;

jclass cls_coder = e->FindClass("javaforce/media/MediaCoder");

jfieldID fid_ff_ctx = e->GetFieldID(cls_coder, "ctx", "J");

ctx = (FFContext*)e->GetLongField(c, fid_ff_ctx);

if (ctx == NULL) return NULL;

ctx->e = e;

ctx->c = c;

return ctx;

}

void deleteFFContext(JNIEnv *e, jobject c, FFContext *ctx) {

}

static int read_packet(FFContext *ctx, void*buf, int size) {

}

typedef struct mp4_box {

int size;

char type[4];

} mp4_box;

static int swap_order(int val) {

}

static int write_packet(FFContext *ctx, void*buf, int size) {

}

static jlong zero = 0;

static jlong seek_packet(FFContext *ctx, jlong offset, int how) {

}

static int decoder_open_codec_context(FFContext *ctx, AVFormatContext *fmt_ctx, int type)

}

static jboolean decoder_open_codecs(FFContext *ctx, int new_width, int new_height, int new_chs, int new_freq) {

}

JNIEXPORT jboolean JNICALL Java_javaforce_media_MediaDecoder_start

}

JNIEXPORT jboolean JNICALL Java_javaforce_media_MediaDecoder_startFile

}

JNIEXPORT void JNICALL Java_javaforce_media_MediaDecoder_stop

}

JNIEXPORT jint JNICALL Java_javaforce_media_MediaDecoder_read