QTRLE is supported by ffmpeg?

Question

• I am trying to create video using QTRLE format with RGB24 or ARGB pixel format in ffmpeg library.But video is not played.
• But is i use H264 format with yuv format then it's working fine.

• Is QTRLE is not supported by ffmpeg or i m doing any mistake?

  static void video_encode_example(const char *filename, int codec_id)
  {
          AVCodec *codec;
          AVCodecContext *c = NULL;
          int i, ret, x, y, got_output;
          FILE *f;
          AVFrame *frame;
          AVPacket pkt;
          uint8_t endcode[] = { 0, 0, 1, 0xb7 };
  
          printf("Encode video file %s\n", filename);
  
          /* find the mpeg1 video encoder */
  
          codec = avcodec_find_encoder((AVCodecID) codec_id);
          //  codec = 28;
          if (!codec) {
              fprintf(stderr, "Codec not found : %d\n", codec_id);
              exit(1);
          }
  
          c = avcodec_alloc_context3(codec);
  
          if (!c) {
              fprintf(stderr, "Could not allocate video codec context\n");
              exit(1);
          }
  
          /* put sample parameters */
          c->bit_rate = 400000;
          /* resolution must be a multiple of two */
          c->width = 352;
          c->height = 288;
          /* frames per second */
          c->time_base = (AVRational ) { 1, 25 };
          /* emit one intra frame every ten frames
           * check frame pict_type before passing frame
           * to encoder, if frame->pict_type is AV_PICTURE_TYPE_I
           * then gop_size is ignored and the output of encoder
           * will always be I frame irrespective to gop_size
           */
          c->gop_size = 10;
          c->max_b_frames = 1;
          c->pix_fmt = AV_PIX_FMT_RGB24;
  
          if (codec_id == AV_CODEC_ID_H264)
              av_opt_set(c->priv_data, "preset", "slow", 0);
  
          /* open it */
          if (avcodec_open2(c, codec, NULL) < 0) {
              fprintf(stderr, "Could not open codec\n");
              exit(1);
          }
  
          f = fopen(filename, "wb");
          if (!f) {
              fprintf(stderr, "Could not open %s\n", filename);
              exit(1);
          }
  
          frame = av_frame_alloc();
          if (!frame) {
              fprintf(stderr, "Could not allocate video frame\n");
              exit(1);
          }
          frame->format = c->pix_fmt;
          frame->width = c->width;
          frame->height = c->height;
  
          /* the image can be allocated by any means and av_image_alloc() is
           * just the most convenient way if av_malloc() is to be used */
          ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height,
                  c->pix_fmt, 32);
          if (ret < 0) {
              fprintf(stderr, "Could not allocate raw picture buffer\n");
              exit(1);
          }
          ////////////////////////////////////
          cv::Mat input = imread("image for creating video(image.png)");
          Mat output;
          resize(input, input, Size(c->width, c->height));
          cvtColor(input, input, CV_BGR2RGB);
  
          av_image_fill_arrays(frame->data, frame->linesize, input.data,
                  c->pix_fmt, c->width, c->height, 1);
  
          ////////////////////////////////////
  
          for (i = 0; i < 250; i++) {
              av_init_packet(&pkt);
              pkt.data = NULL;    // packet data will be allocated by the encoder
              pkt.size = 0;
  
              fflush(stdout);
  
              frame->pts = i;
  
              /* encode the image */
              ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
              if (ret < 0) {
                  fprintf(stderr, "Error encoding frame\n");
                  exit(1);
              }
  
              if (got_output) {
                  printf("Write frame %3d (size=%5d)\n", i, pkt.size);
                  fwrite(pkt.data, 1, pkt.size, f);
                  av_packet_unref(&pkt);
              }
          }
  
          /* get the delayed frames */
          for (got_output = 1; got_output; i++) {
              fflush(stdout);
  
              ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
              if (ret < 0) {
                  fprintf(stderr, "Error encoding frame\n");
                  exit(1);
              }
  
              if (got_output) {
                  printf("Write frame %3d (size=%5d)\n", i, pkt.size);
                  fwrite(pkt.data, 1, pkt.size, f);
                  av_packet_unref(&pkt);
              }
          }
  
          /* add sequence end code to have a real mpeg file */
          fwrite(endcode, 1, sizeof(endcode), f);
          fclose(f);
  
          avcodec_close(c);
          av_free(c);
      //  av_freep(&frame->data[0]);
          av_frame_free(&frame);
          printf("\n");
  }
  
  int main() {
      av_register_all();
      video_encode_example("test.mov", AV_CODEC_ID_QTRLE);
  }
  

Answer 1

FFmpeg supports QTRLE, the problem is you're looking at the wrong example.

The code you provided seems to be based on decoding_encoding.c which is an example of libavcodec usage that works on codecs only. It only outputs raw h264 or mpg.

If you want to create a mov file you must mux the result in this format using libavformat. See the muxing.c example instead.