doc/examples/qsv_transcode.c

   1 /*
   2  * Permission is hereby granted, free of charge, to any person obtaining a copy
   3  * of this software and associated documentation files (the "Software"), to deal
   4  * in the Software without restriction, including without limitation the rights
   5  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   6  * copies of the Software, and to permit persons to whom the Software is
   7  * furnished to do so, subject to the following conditions:
   8  *
   9  * The above copyright notice and this permission notice shall be included in
  10  * all copies or substantial portions of the Software.
  11  *
  12  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  13  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  14  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  15  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  16  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  17  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  18  * THE SOFTWARE.
  19  */
  20
  21 /**
  22  * @file Intel QSV-accelerated video transcoding API usage example
  23  * @example qsv_transcode.c
  24  *
  25  * Perform QSV-accelerated transcoding and show to dynamically change
  26  * encoder's options.
  27  *
  28  * Usage: qsv_transcode input_stream codec output_stream initial option
  29  *                      { frame_number new_option }
  30  * e.g: - qsv_transcode input.mp4 h264_qsv output_h264.mp4 "g 60"
  31  *      - qsv_transcode input.mp4 hevc_qsv output_hevc.mp4 "g 60 async_depth 1"
  32  *                      100 "g 120"
  33  *         (initialize codec with gop_size 60 and change it to 120 after 100
  34  *          frames)
  35  */
  36
  37 #include <stdio.h>
  38 #include <errno.h>
  39
  40 #include <libavutil/hwcontext.h>
  41 #include <libavcodec/avcodec.h>
  42 #include <libavformat/avformat.h>
  43 #include <libavutil/opt.h>
  44
  45 static AVFormatContext *ifmt_ctx = NULL, *ofmt_ctx = NULL;
  46 static AVBufferRef *hw_device_ctx = NULL;
  47 static AVCodecContext *decoder_ctx = NULL, *encoder_ctx = NULL;
  48 static int video_stream = -1;
  49
  50 typedef struct DynamicSetting {
  51     int frame_number;
  52     char* optstr;
  53 } DynamicSetting;
  54 static DynamicSetting *dynamic_setting;
  55 static int setting_number;
  56 static int current_setting_number;
  57
  58 static int str_to_dict(char* optstr, AVDictionary **opt)
  59 {
  60     char *key, *value;
  61     if (strlen(optstr) == 0)
  62         return 0;
  63     key = strtok(optstr, " ");
  64     if (key == NULL)
  65         return AVERROR(ENAVAIL);
  66     value = strtok(NULL, " ");
  67     if (value == NULL)
  68         return AVERROR(ENAVAIL);
  69     av_dict_set(opt, key, value, 0);
  70     do {
  71         key = strtok(NULL, " ");
  72         if (key == NULL)
  73             return 0;
  74         value = strtok(NULL, " ");
  75         if (value == NULL)
  76             return AVERROR(ENAVAIL);
  77         av_dict_set(opt, key, value, 0);
  78     } while(key != NULL);
  79     return 0;
  80 }
  81
  82 static int dynamic_set_parameter(AVCodecContext *avctx)
  83 {
  84     AVDictionary *opts = NULL;
  85     int ret = 0;
  86     static int frame_number = 0;
  87     frame_number++;
  88     if (current_setting_number < setting_number &&
  89         frame_number == dynamic_setting[current_setting_number].frame_number) {
  90         AVDictionaryEntry *e = NULL;
  91         ret = str_to_dict(dynamic_setting[current_setting_number++].optstr, &opts);
  92         if (ret < 0) {
  93             fprintf(stderr, "The dynamic parameter is wrong\n");
  94             goto fail;
  95         }
  96         /* Set common option. The dictionary will be freed and replaced
  97          * by a new one containing all options not found in common option list.
  98          * Then this new dictionary is used to set private option. */
  99         if ((ret = av_opt_set_dict(avctx, &opts)) < 0)
 100             goto fail;
 101         /* Set codec specific option */
 102         if ((ret = av_opt_set_dict(avctx->priv_data, &opts)) < 0)
 103             goto fail;
 104         /* There is no "framerate" option in commom option list. Use "-r" to set
 105          * framerate, which is compatible with ffmpeg commandline. The video is
 106          * assumed to be average frame rate, so set time_base to 1/framerate. */
 107         e = av_dict_get(opts, "r", NULL, 0);
 108         if (e) {
 109             avctx->framerate = av_d2q(atof(e->value), INT_MAX);
 110             encoder_ctx->time_base = av_inv_q(encoder_ctx->framerate);
 111         }
 112     }
 113 fail:
 114     av_dict_free(&opts);
 115     return ret;
 116 }
 117
 118 static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
 119 {
 120     while (*pix_fmts != AV_PIX_FMT_NONE) {
 121         if (*pix_fmts == AV_PIX_FMT_QSV) {
 122             return AV_PIX_FMT_QSV;
 123         }
 124
 125         pix_fmts++;
 126     }
 127
 128     fprintf(stderr, "The QSV pixel format not offered in get_format()\n");
 129
 130     return AV_PIX_FMT_NONE;
 131 }
 132
 133 static int open_input_file(char *filename)
 134 {
 135     int ret;
 136     const AVCodec *decoder = NULL;
 137     AVStream *video = NULL;
 138
 139     if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
 140         fprintf(stderr, "Cannot open input file '%s', Error code: %s\n",
 141                 filename, av_err2str(ret));
 142         return ret;
 143     }
 144
 145     if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
 146         fprintf(stderr, "Cannot find input stream information. Error code: %s\n",
 147                 av_err2str(ret));
 148         return ret;
 149     }
 150
 151     ret = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
 152     if (ret < 0) {
 153         fprintf(stderr, "Cannot find a video stream in the input file. "
 154                 "Error code: %s\n", av_err2str(ret));
 155         return ret;
 156     }
 157     video_stream = ret;
 158     video = ifmt_ctx->streams[video_stream];
 159
 160     switch(video->codecpar->codec_id) {
 161     case AV_CODEC_ID_H264:
 162         decoder = avcodec_find_decoder_by_name("h264_qsv");
 163         break;
 164     case AV_CODEC_ID_HEVC:
 165         decoder = avcodec_find_decoder_by_name("hevc_qsv");
 166         break;
 167     case AV_CODEC_ID_VP9:
 168         decoder = avcodec_find_decoder_by_name("vp9_qsv");
 169         break;
 170     case AV_CODEC_ID_VP8:
 171         decoder = avcodec_find_decoder_by_name("vp8_qsv");
 172         break;
 173     case AV_CODEC_ID_AV1:
 174         decoder = avcodec_find_decoder_by_name("av1_qsv");
 175         break;
 176     case AV_CODEC_ID_MPEG2VIDEO:
 177         decoder = avcodec_find_decoder_by_name("mpeg2_qsv");
 178         break;
 179     case AV_CODEC_ID_MJPEG:
 180         decoder = avcodec_find_decoder_by_name("mjpeg_qsv");
 181         break;
 182     default:
 183         fprintf(stderr, "Codec is not supportted by qsv\n");
 184         return AVERROR(ENAVAIL);
 185     }
 186
 187     if (!(decoder_ctx = avcodec_alloc_context3(decoder)))
 188         return AVERROR(ENOMEM);
 189
 190     if ((ret = avcodec_parameters_to_context(decoder_ctx, video->codecpar)) < 0) {
 191         fprintf(stderr, "avcodec_parameters_to_context error. Error code: %s\n",
 192                 av_err2str(ret));
 193         return ret;
 194     }
 195     decoder_ctx->framerate = av_guess_frame_rate(ifmt_ctx, video, NULL);
 196
 197     decoder_ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
 198     if (!decoder_ctx->hw_device_ctx) {
 199         fprintf(stderr, "A hardware device reference create failed.\n");
 200         return AVERROR(ENOMEM);
 201     }
 202     decoder_ctx->get_format    = get_format;
 203     decoder_ctx->pkt_timebase = video->time_base;
 204     if ((ret = avcodec_open2(decoder_ctx, decoder, NULL)) < 0)
 205         fprintf(stderr, "Failed to open codec for decoding. Error code: %s\n",
 206                 av_err2str(ret));
 207
 208     return ret;
 209 }
 210
 211 static int encode_write(AVPacket *enc_pkt, AVFrame *frame)
 212 {
 213     int ret = 0;
 214
 215     av_packet_unref(enc_pkt);
 216
 217     if((ret = dynamic_set_parameter(encoder_ctx)) < 0) {
 218         fprintf(stderr, "Failed to set dynamic parameter. Error code: %s\n",
 219                 av_err2str(ret));
 220         goto end;
 221     }
 222
 223     if ((ret = avcodec_send_frame(encoder_ctx, frame)) < 0) {
 224         fprintf(stderr, "Error during encoding. Error code: %s\n", av_err2str(ret));
 225         goto end;
 226     }
 227     while (1) {
 228         if (ret = avcodec_receive_packet(encoder_ctx, enc_pkt))
 229             break;
 230         enc_pkt->stream_index = 0;
 231         av_packet_rescale_ts(enc_pkt, encoder_ctx->time_base,
 232                              ofmt_ctx->streams[0]->time_base);
 233         if ((ret = av_interleaved_write_frame(ofmt_ctx, enc_pkt)) < 0) {
 234             fprintf(stderr, "Error during writing data to output file. "
 235                     "Error code: %s\n", av_err2str(ret));
 236             return ret;
 237         }
 238     }
 239
 240 end:
 241     if (ret == AVERROR_EOF)
 242         return 0;
 243     ret = ((ret == AVERROR(EAGAIN)) ? 0:-1);
 244     return ret;
 245 }
 246
 247 static int dec_enc(AVPacket *pkt, const AVCodec *enc_codec, char *optstr)
 248 {
 249     AVFrame *frame;
 250     int ret = 0;
 251
 252     ret = avcodec_send_packet(decoder_ctx, pkt);
 253     if (ret < 0) {
 254         fprintf(stderr, "Error during decoding. Error code: %s\n", av_err2str(ret));
 255         return ret;
 256     }
 257
 258     while (ret >= 0) {
 259         if (!(frame = av_frame_alloc()))
 260             return AVERROR(ENOMEM);
 261
 262         ret = avcodec_receive_frame(decoder_ctx, frame);
 263         if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
 264             av_frame_free(&frame);
 265             return 0;
 266         } else if (ret < 0) {
 267             fprintf(stderr, "Error while decoding. Error code: %s\n", av_err2str(ret));
 268             goto fail;
 269         }
 270         if (!encoder_ctx->hw_frames_ctx) {
 271             AVDictionaryEntry *e = NULL;
 272             AVDictionary *opts = NULL;
 273             AVStream *ost;
 274             /* we need to ref hw_frames_ctx of decoder to initialize encoder's codec.
 275                Only after we get a decoded frame, can we obtain its hw_frames_ctx */
 276             encoder_ctx->hw_frames_ctx = av_buffer_ref(decoder_ctx->hw_frames_ctx);
 277             if (!encoder_ctx->hw_frames_ctx) {
 278                 ret = AVERROR(ENOMEM);
 279                 goto fail;
 280             }
 281             /* set AVCodecContext Parameters for encoder, here we keep them stay
 282              * the same as decoder.
 283              */
 284             encoder_ctx->time_base = av_inv_q(decoder_ctx->framerate);
 285             encoder_ctx->pix_fmt   = AV_PIX_FMT_QSV;
 286             encoder_ctx->width     = decoder_ctx->width;
 287             encoder_ctx->height    = decoder_ctx->height;
 288             if ((ret = str_to_dict(optstr, &opts)) < 0) {
 289                 fprintf(stderr, "Failed to set encoding parameter.\n");
 290                 goto fail;
 291             }
 292             /* There is no "framerate" option in commom option list. Use "-r" to
 293             * set framerate, which is compatible with ffmpeg commandline. The
 294             * video is assumed to be average frame rate, so set time_base to
 295             * 1/framerate. */
 296             e = av_dict_get(opts, "r", NULL, 0);
 297             if (e) {
 298                 encoder_ctx->framerate = av_d2q(atof(e->value), INT_MAX);
 299                 encoder_ctx->time_base = av_inv_q(encoder_ctx->framerate);
 300             }
 301             if ((ret = avcodec_open2(encoder_ctx, enc_codec, &opts)) < 0) {
 302                 fprintf(stderr, "Failed to open encode codec. Error code: %s\n",
 303                         av_err2str(ret));
 304                 av_dict_free(&opts);
 305                 goto fail;
 306             }
 307             av_dict_free(&opts);
 308
 309             if (!(ost = avformat_new_stream(ofmt_ctx, enc_codec))) {
 310                 fprintf(stderr, "Failed to allocate stream for output format.\n");
 311                 ret = AVERROR(ENOMEM);
 312                 goto fail;
 313             }
 314
 315             ost->time_base = encoder_ctx->time_base;
 316             ret = avcodec_parameters_from_context(ost->codecpar, encoder_ctx);
 317             if (ret < 0) {
 318                 fprintf(stderr, "Failed to copy the stream parameters. "
 319                         "Error code: %s\n", av_err2str(ret));
 320                 goto fail;
 321             }
 322
 323             /* write the stream header */
 324             if ((ret = avformat_write_header(ofmt_ctx, NULL)) < 0) {
 325                 fprintf(stderr, "Error while writing stream header. "
 326                         "Error code: %s\n", av_err2str(ret));
 327                 goto fail;
 328             }
 329         }
 330         frame->pts = av_rescale_q(frame->pts, decoder_ctx->pkt_timebase,
 331                                   encoder_ctx->time_base);
 332         if ((ret = encode_write(pkt, frame)) < 0)
 333             fprintf(stderr, "Error during encoding and writing.\n");
 334
 335 fail:
 336         av_frame_free(&frame);
 337         if (ret < 0)
 338             return ret;
 339     }
 340     return 0;
 341 }
 342
 343 int main(int argc, char **argv)
 344 {
 345     const AVCodec *enc_codec;
 346     int ret = 0;
 347     AVPacket *dec_pkt;
 348
 349     if (argc < 5 || (argc - 5) % 2) {
 350         av_log(NULL, AV_LOG_ERROR, "Usage: %s <input file> <encoder> <output file>"
 351                " <\"encoding option set 0\"> [<frame_number> <\"encoding options set 1\">]...\n", argv[0]);
 352         return 1;
 353     }
 354     setting_number = (argc - 5) / 2;
 355     dynamic_setting = av_malloc(setting_number * sizeof(*dynamic_setting));
 356     current_setting_number = 0;
 357     for (int i = 0; i < setting_number; i++) {
 358         dynamic_setting[i].frame_number = atoi(argv[i*2 + 5]);
 359         dynamic_setting[i].optstr = argv[i*2 + 6];
 360     }
 361
 362     ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_QSV, NULL, NULL, 0);
 363     if (ret < 0) {
 364         fprintf(stderr, "Failed to create a QSV device. Error code: %s\n", av_err2str(ret));
 365         goto end;
 366     }
 367
 368     dec_pkt = av_packet_alloc();
 369     if (!dec_pkt) {
 370         fprintf(stderr, "Failed to allocate decode packet\n");
 371         goto end;
 372     }
 373
 374     if ((ret = open_input_file(argv[1])) < 0)
 375         goto end;
 376
 377     if (!(enc_codec = avcodec_find_encoder_by_name(argv[2]))) {
 378         fprintf(stderr, "Could not find encoder '%s'\n", argv[2]);
 379         ret = -1;
 380         goto end;
 381     }
 382
 383     if ((ret = (avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, argv[3]))) < 0) {
 384         fprintf(stderr, "Failed to deduce output format from file extension. Error code: "
 385                 "%s\n", av_err2str(ret));
 386         goto end;
 387     }
 388
 389     if (!(encoder_ctx = avcodec_alloc_context3(enc_codec))) {
 390         ret = AVERROR(ENOMEM);
 391         goto end;
 392     }
 393
 394     ret = avio_open(&ofmt_ctx->pb, argv[3], AVIO_FLAG_WRITE);
 395     if (ret < 0) {
 396         fprintf(stderr, "Cannot open output file. "
 397                 "Error code: %s\n", av_err2str(ret));
 398         goto end;
 399     }
 400
 401     /* read all packets and only transcoding video */
 402     while (ret >= 0) {
 403         if ((ret = av_read_frame(ifmt_ctx, dec_pkt)) < 0)
 404             break;
 405
 406         if (video_stream == dec_pkt->stream_index)
 407             ret = dec_enc(dec_pkt, enc_codec, argv[4]);
 408
 409         av_packet_unref(dec_pkt);
 410     }
 411
 412     /* flush decoder */
 413     av_packet_unref(dec_pkt);
 414     if ((ret = dec_enc(dec_pkt, enc_codec, argv[4])) < 0) {
 415         fprintf(stderr, "Failed to flush decoder %s\n", av_err2str(ret));
 416         goto end;
 417     }
 418
 419     /* flush encoder */
 420     if ((ret = encode_write(dec_pkt, NULL)) < 0) {
 421         fprintf(stderr, "Failed to flush encoder %s\n", av_err2str(ret));
 422         goto end;
 423     }
 424
 425     /* write the trailer for output stream */
 426     if ((ret = av_write_trailer(ofmt_ctx)) < 0)
 427         fprintf(stderr, "Failed to write trailer %s\n", av_err2str(ret));
 428
 429 end:
 430     avformat_close_input(&ifmt_ctx);
 431     avformat_close_input(&ofmt_ctx);
 432     avcodec_free_context(&decoder_ctx);
 433     avcodec_free_context(&encoder_ctx);
 434     av_buffer_unref(&hw_device_ctx);
 435     av_packet_free(&dec_pkt);
 436     av_freep(&dynamic_setting);
 437     return ret;
 438 }