Losing quality when encoding with ffmpeg

Question

I am using the c libraries of ffmpeg to read frames from a video and create an output file that is supposed to be identical to the input. However, somewhere during this process some quality gets lost and the result is "less sharp". My guess is that the problem is the encoding and that the frames are too compressed (also because the size of the file decreases quite significantly). Is there some parameter in the encoder that allows me to control the quality of the result? I found that AVCodecContext has a compression_level member, but changing it that does not seem to have any effect.

I post here part of my code in case it could help. I would say that something must be changed in the init function of OutputVideoBuilder when I set the codec. The AVCodecContext that is passed to the method is the same of InputVideoHandler. Here are the two main classes that I created to wrap the ffmpeg functionalities:

// This class opens the video files and sets the decoder
class InputVideoHandler {
public:
  InputVideoHandler(char* name);
  ~InputVideoHandler();
  AVCodecContext* getCodecContext();
  bool readFrame(AVFrame* frame, int* success);

private:
  InputVideoHandler();
  void init(char* name);
  AVFormatContext* formatCtx;
  AVCodec* codec;
  AVCodecContext* codecCtx;
  AVPacket packet;
  int streamIndex;
};

void InputVideoHandler::init(char* name) {
  streamIndex = -1;
  int numStreams;

  if (avformat_open_input(&formatCtx, name, NULL, NULL) != 0)
    throw std::exception("Invalid input file name.");

  if (avformat_find_stream_info(formatCtx, NULL)<0)
    throw std::exception("Could not find stream information.");

  numStreams = formatCtx->nb_streams;

  if (numStreams < 0)
    throw std::exception("No streams in input video file.");

  for (int i = 0; i < numStreams; i++) {
    if (formatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
      streamIndex = i;
      break;
    }
  }

  if (streamIndex < 0)
    throw std::exception("No video stream in input video file.");

  // find decoder using id
  codec = avcodec_find_decoder(formatCtx->streams[streamIndex]->codec->codec_id);
  if (codec == nullptr)
    throw std::exception("Could not find suitable decoder for input file.");

  // copy context from input stream
  codecCtx = avcodec_alloc_context3(codec);
  if (avcodec_copy_context(codecCtx, formatCtx->streams[streamIndex]->codec) != 0)
    throw std::exception("Could not copy codec context from input stream.");

  if (avcodec_open2(codecCtx, codec, NULL) < 0)
    throw std::exception("Could not open decoder.");
}

// frame must be initialized with av_frame_alloc() before!
// Returns true if there are other frames, false if not.
// success == 1 if frame is valid, 0 if not.
bool InputVideoHandler::readFrame(AVFrame* frame, int* success) {
  *success = 0;
  if (av_read_frame(formatCtx, &packet) < 0)
    return false;
  if (packet.stream_index == streamIndex) {
    avcodec_decode_video2(codecCtx, frame, success, &packet);
  }
  av_free_packet(&packet);
  return true;
}

// This class opens the output and write frames to it
class OutputVideoBuilder{
public:
  OutputVideoBuilder(char* name, AVCodecContext* inputCtx);
  ~OutputVideoBuilder();
  void writeFrame(AVFrame* frame);
  void writeVideo();

private:
  OutputVideoBuilder();
  void init(char* name, AVCodecContext* inputCtx);
  void logMsg(AVPacket* packet, AVRational* tb);
  AVFormatContext* formatCtx;
  AVCodec* codec;
  AVCodecContext* codecCtx;
  AVStream* stream;
};

void OutputVideoBuilder::init(char* name, AVCodecContext* inputCtx) {
  if (avformat_alloc_output_context2(&formatCtx, NULL, NULL, name) < 0)
    throw std::exception("Could not determine file extension from provided name.");

  codec = avcodec_find_encoder(inputCtx->codec_id);
  if (codec == nullptr) {
    throw std::exception("Could not find suitable encoder.");
  }

  codecCtx = avcodec_alloc_context3(codec);
  if (avcodec_copy_context(codecCtx, inputCtx) < 0)
    throw std::exception("Could not copy output codec context from input");

  codecCtx->time_base = inputCtx->time_base;
  codecCtx->compression_level = 0;

  if (avcodec_open2(codecCtx, codec, NULL) < 0)
    throw std::exception("Could not open encoder.");

  stream = avformat_new_stream(formatCtx, codec);
  if (stream == nullptr) {
    throw std::exception("Could not allocate stream.");
  }

  stream->id = formatCtx->nb_streams - 1;
  stream->codec = codecCtx;
  stream->time_base = codecCtx->time_base;



  av_dump_format(formatCtx, 0, name, 1);
  if (!(formatCtx->oformat->flags & AVFMT_NOFILE)) {
    if (avio_open(&formatCtx->pb, name, AVIO_FLAG_WRITE) < 0) {
      throw std::exception("Could not open output file.");
    }
  }

  if (avformat_write_header(formatCtx, NULL) < 0) {
    throw std::exception("Error occurred when opening output file.");
  }

}

void OutputVideoBuilder::writeFrame(AVFrame* frame) {
  AVPacket packet = { 0 };
  int success;
  av_init_packet(&packet);

  if (avcodec_encode_video2(codecCtx, &packet, frame, &success))
    throw std::exception("Error encoding frames");

  if (success) {
    av_packet_rescale_ts(&packet, codecCtx->time_base, stream->time_base);
    packet.stream_index = stream->index;
    logMsg(&packet,&stream->time_base);
    av_interleaved_write_frame(formatCtx, &packet);
  }
  av_free_packet(&packet);
}

This is the part of the main function that reads and write frames:

 while (inputHandler->readFrame(frame,&gotFrame)) {

    if (gotFrame) {
      try {
        outputBuilder->writeFrame(frame);
      }
      catch (std::exception e) {
        std::cout << e.what() << std::endl;
        return -1;
      }
    }
  }

Answer 1

Your qmin/qmax answer is partially correct, but it misses the point, in that the quality indeed goes up, but the compression ratio (in terms of quality per bit) will suffer significantly as you restrict the qmin/qmax range - i.e. you will spend many more bits to accomplish the same quality than should really be necessary if you used the encoder optimally.

To increase quality without hurting the compression ratio, you need to actually increase the quality target. How you do this differs a little depending on the codec, but you typically increase the target CRF value or target bitrate. For commandline options, see e.g. the H264 docs. There's identical docs for HEVC/VP9 also. To use these options in the C API, use av_opt_set() with the same option names/values.

Answer 2

In case this could be useful to someone else, I add the answer that damjeux suggested, which worked for me. AVCodecContex has two members qmin and qmax which control the QP (quantization parameter) of the encoder. By default in my case qmin is 2 and qmax is 31. By setting qmax to a lower value the quality of the output improves.