extern "C" {
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
#include <libavutil/imgutils.h>
}

int error;

AVFormatContext* inputFormatContext = NULL;
AVFormatContext* outputFormatContext = NULL;

AVCodecContext* encoderContext;
AVCodecContext* decoderContext;

SwsContext *swsCtx = nullptr;

AVCodec* decoderCodec;

AVPacket* decodePacket;
AVPacket* encodePacket;

AVFrame* inputFrame;
AVFrame* outputFrame;

int main(int argc, char **argv) {

  if (argc < 3) {
    puts("2 arguments are required, input file and output file.");
    return 0;
  }

  //av_log_set_level(AV_LOG_ERROR);

  char* inputFile = argv[1];
  char* outputFile = argv[2];

  error = avformat_open_input(&inputFormatContext, inputFile, NULL, NULL);

  if (error) {
    return 1;
  }

  error = avformat_find_stream_info(inputFormatContext, NULL);

  if (error) {
    return 1;
  }

  int streamIndex = av_find_best_stream(inputFormatContext, AVMEDIA_TYPE_VIDEO,
      -1, -1, nullptr, 0);

  if (streamIndex < 0) {
    error = AVERROR_UNKNOWN;
    return 1;
  }

  AVStream* stream = inputFormatContext->streams[streamIndex];

  AVCodecParameters* codecParameters = stream->codecpar;

  if (!codecParameters->codec_id) {
    error = AVERROR_UNKNOWN;
    return 1;
  }

  //Opening input
  decoderCodec = avcodec_find_decoder(codecParameters->codec_id);

  decoderContext = avcodec_alloc_context3(decoderCodec);
  if (!decoderContext) {
    error = AVERROR_UNKNOWN;
    return 1;
  }

  error = avcodec_parameters_to_context(decoderContext, codecParameters);

  if (error) {
    return 1;
  }

  decoderContext->thread_count = 0;
  error = avcodec_open2(decoderContext, decoderCodec, nullptr);

  if (error) {
    return 1;
  }
//Opened input

//init frames

  inputFrame = av_frame_alloc();

  if (!inputFrame) {
    error = AVERROR_UNKNOWN;
    return 1;
  }

  outputFrame = av_frame_alloc();

  if (!outputFrame) {
    error = AVERROR_UNKNOWN;
    return 1;
  }

  decodePacket = av_packet_alloc();

  if (!decodePacket) {
    error = AVERROR_UNKNOWN;
    return 1;
  }

  encodePacket = av_packet_alloc();

  if (!encodePacket) {
    error = AVERROR_UNKNOWN;
    return 1;
  }

  avformat_alloc_output_context2(&outputFormatContext, NULL, NULL, outputFile);

  outputFormatContext->video_codec_id = av_guess_codec(
      outputFormatContext->oformat, NULL, outputFile, NULL, AVMEDIA_TYPE_VIDEO);

  outputFormatContext->video_codec = avcodec_find_encoder(
      outputFormatContext->video_codec_id);

  if (!outputFormatContext->video_codec) {
    error = AVERROR_UNKNOWN;
    return 1;
  }

  encoderContext = avcodec_alloc_context3(outputFormatContext->video_codec);

  if (!encoderContext) {
    error = AVERROR_UNKNOWN;
    return 1;
  }

  encoderContext->width = 100;
  encoderContext->height = 100;

  encoderContext->pix_fmt = avcodec_find_best_pix_fmt_of_list(
      outputFormatContext->video_codec->pix_fmts, decoderContext->pix_fmt, true,
      NULL);

  if (stream->avg_frame_rate.den) {
    encoderContext->time_base = av_make_q(1,
        (stream->avg_frame_rate.num + (stream->avg_frame_rate.den / 2))
            / stream->avg_frame_rate.den);
  } else {
    encoderContext->time_base = av_make_q(1, 1);
  }

  error = avcodec_open2(encoderContext, outputFormatContext->video_codec,
      nullptr);

  if (error) {
    return 1;
  }
  //init encoder

  swsCtx = sws_getContext(decoderContext->width, decoderContext->height,
      decoderContext->pix_fmt, encoderContext->width, encoderContext->height,
      encoderContext->pix_fmt, 0, nullptr, nullptr, nullptr);

  if (!swsCtx) {
    error = AVERROR_UNKNOWN;
    return 1;
  }

  outputFrame->format = encoderContext->pix_fmt;
  outputFrame->width = encoderContext->width;
  outputFrame->height = encoderContext->height;

  //error = av_frame_get_buffer(outputFrame, 0);
  error = av_image_alloc(outputFrame->data, outputFrame->linesize,
      encoderContext->width, encoderContext->height, encoderContext->pix_fmt,
      32);

  if (error < 0) {
    return 1;
  }

  AVStream* out_stream = avformat_new_stream(outputFormatContext, NULL);

  error = avcodec_parameters_from_context(out_stream->codecpar, decoderContext);

  if (error) {
    return 1;
  }

  if (!(outputFormatContext->oformat->flags & AVFMT_NOFILE)) {
    error = avio_open(&outputFormatContext->pb, outputFile, AVIO_FLAG_WRITE);
    if (error < 0) {
      return 1;
    }
  }

  AVDictionary *opts;

  av_dict_set(&opts, "loop", "0", 0);

  error = avformat_write_header(outputFormatContext, &opts);

  if (error) {
    return 1;
  }

  while (true) {

    // av_frame_unref(inputFrame);
    //av_packet_unref(decodePacket);

    //probably ended frames
    if (av_read_frame(inputFormatContext, decodePacket) < 0) {
      error = 0;
      break;
    }

    //different stream. ignore.
    if (decodePacket->stream_index != streamIndex) {
      continue;
    }

    //send packet
    error = avcodec_send_packet(decoderContext, decodePacket);

    if (error < 0) {

      //get next one
      if (error == AVERROR(EAGAIN)) {
        continue;
      } else {
        return 1;
      }
    }

    //send frame
    error = avcodec_receive_frame(decoderContext, inputFrame);

    if (error < 0) {

      //get next one
      if (error == AVERROR(EAGAIN)) {
        continue;
      } else {
        return 1;
      }
    }

    if (!sws_scale(swsCtx, inputFrame->data, inputFrame->linesize, 0,
        inputFrame->height, outputFrame->data, outputFrame->linesize)) {
      return 1;
    }

    error = avcodec_send_frame(encoderContext, outputFrame);

    if (error) {
      return 1;
    }

    error = avcodec_receive_packet(encoderContext, encodePacket);

    if (error) {
      return 1;
    }

    encodePacket->pts = av_rescale_q_rnd(decodePacket->pts, stream->time_base,
        out_stream->time_base,
        static_cast<AVRounding>(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
    encodePacket->dts = av_rescale_q_rnd(decodePacket->dts, stream->time_base,
        out_stream->time_base,
        static_cast<AVRounding>(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
    encodePacket->duration = av_rescale_q(decodePacket->duration,
        stream->time_base, out_stream->time_base);
    encodePacket->pos = -1;

    error = av_interleaved_write_frame(outputFormatContext, encodePacket);

    if (error < 0) {
      return 1;
    }

  }

  error = av_write_trailer(outputFormatContext);

  if (error) {
    return 1;
  }

  puts("Finished conversion.");

  if (!(outputFormatContext->oformat->flags & AVFMT_NOFILE)) {
    avio_closep(&outputFormatContext->pb);
  }

  av_packet_unref(encodePacket);
  av_packet_unref(decodePacket);

  avcodec_send_packet(decoderContext, nullptr);
  avcodec_send_packet(encoderContext, nullptr);

  av_freep(&outputFrame->data);

  av_frame_free(&inputFrame);
  av_frame_free(&outputFrame);

  sws_freeContext(swsCtx);

  av_packet_free(&encodePacket);
  av_packet_free(&decodePacket);

  avcodec_free_context(&encoderContext);
  avcodec_free_context(&decoderContext);

  avformat_close_input(&inputFormatContext);
  avformat_free_context(outputFormatContext);

  return 0;
}