git.sesse.net Git - ffmpeg/blob - doc/examples/vaapi_transcode.c

   1 /*
   2  * Video Acceleration API (video transcoding) transcode sample
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  17  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20  * THE SOFTWARE.
  21  */
  22
  23 /**
  24  * @file
  25  * Intel VAAPI-accelerated transcoding example.
  26  *
  27  * @example vaapi_transcode.c
  28  * This example shows how to do VAAPI-accelerated transcoding.
  29  * Usage: vaapi_transcode input_stream codec output_stream
  30  * e.g: - vaapi_transcode input.mp4 h264_vaapi output_h264.mp4
  31  *      - vaapi_transcode input.mp4 vp9_vaapi output_vp9.ivf
  32  */
  33
  34 #include <stdio.h>
  35 #include <errno.h>
  36
  37 #include <libavutil/hwcontext.h>
  38 #include <libavcodec/avcodec.h>
  39 #include <libavformat/avformat.h>
  40
  41 static AVFormatContext *ifmt_ctx = NULL, *ofmt_ctx = NULL;
  42 static AVBufferRef *hw_device_ctx = NULL;
  43 static AVCodecContext *decoder_ctx = NULL, *encoder_ctx = NULL;
  44 static int video_stream = -1;
  45 static AVStream *ost;
  46 static int initialized = 0;
  47
  48 static enum AVPixelFormat get_vaapi_format(AVCodecContext *ctx,
  49                                            const enum AVPixelFormat *pix_fmts)
  50 {
  51     const enum AVPixelFormat *p;
  52
  53     for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
  54         if (*p == AV_PIX_FMT_VAAPI)
  55             return *p;
  56     }
  57
  58     fprintf(stderr, "Unable to decode this file using VA-API.\n");
  59     return AV_PIX_FMT_NONE;
  60 }
  61
  62 static int open_input_file(const char *filename)
  63 {
  64     int ret;
  65     AVCodec *decoder = NULL;
  66     AVStream *video = NULL;
  67
  68     if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
  69         fprintf(stderr, "Cannot open input file '%s', Error code: %s\n",
  70                 filename, av_err2str(ret));
  71         return ret;
  72     }
  73
  74     if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
  75         fprintf(stderr, "Cannot find input stream information. Error code: %s\n",
  76                 av_err2str(ret));
  77         return ret;
  78     }
  79
  80     ret = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &decoder, 0);
  81     if (ret < 0) {
  82         fprintf(stderr, "Cannot find a video stream in the input file. "
  83                 "Error code: %s\n", av_err2str(ret));
  84         return ret;
  85     }
  86     video_stream = ret;
  87
  88     if (!(decoder_ctx = avcodec_alloc_context3(decoder)))
  89         return AVERROR(ENOMEM);
  90
  91     video = ifmt_ctx->streams[video_stream];
  92     if ((ret = avcodec_parameters_to_context(decoder_ctx, video->codecpar)) < 0) {
  93         fprintf(stderr, "avcodec_parameters_to_context error. Error code: %s\n",
  94                 av_err2str(ret));
  95         return ret;
  96     }
  97
  98     decoder_ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
  99     if (!decoder_ctx->hw_device_ctx) {
 100         fprintf(stderr, "A hardware device reference create failed.\n");
 101         return AVERROR(ENOMEM);
 102     }
 103     decoder_ctx->get_format    = get_vaapi_format;
 104
 105     if ((ret = avcodec_open2(decoder_ctx, decoder, NULL)) < 0)
 106         fprintf(stderr, "Failed to open codec for decoding. Error code: %s\n",
 107                 av_err2str(ret));
 108
 109     return ret;
 110 }
 111
 112 static int encode_write(AVFrame *frame)
 113 {
 114     int ret = 0;
 115     AVPacket enc_pkt;
 116
 117     av_init_packet(&enc_pkt);
 118     enc_pkt.data = NULL;
 119     enc_pkt.size = 0;
 120
 121     if ((ret = avcodec_send_frame(encoder_ctx, frame)) < 0) {
 122         fprintf(stderr, "Error during encoding. Error code: %s\n", av_err2str(ret));
 123         goto end;
 124     }
 125     while (1) {
 126         ret = avcodec_receive_packet(encoder_ctx, &enc_pkt);
 127         if (ret)
 128             break;
 129
 130         enc_pkt.stream_index = 0;
 131         av_packet_rescale_ts(&enc_pkt, ifmt_ctx->streams[video_stream]->time_base,
 132                              ofmt_ctx->streams[0]->time_base);
 133         ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);
 134         if (ret < 0) {
 135             fprintf(stderr, "Error during writing data to output file. "
 136                     "Error code: %s\n", av_err2str(ret));
 137             return -1;
 138         }
 139     }
 140
 141 end:
 142     if (ret == AVERROR_EOF)
 143         return 0;
 144     ret = ((ret == AVERROR(EAGAIN)) ? 0:-1);
 145     return ret;
 146 }
 147
 148 static int dec_enc(AVPacket *pkt, AVCodec *enc_codec)
 149 {
 150     AVFrame *frame;
 151     int ret = 0;
 152
 153     ret = avcodec_send_packet(decoder_ctx, pkt);
 154     if (ret < 0) {
 155         fprintf(stderr, "Error during decoding. Error code: %s\n", av_err2str(ret));
 156         return ret;
 157     }
 158
 159     while (ret >= 0) {
 160         if (!(frame = av_frame_alloc()))
 161             return AVERROR(ENOMEM);
 162
 163         ret = avcodec_receive_frame(decoder_ctx, frame);
 164         if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
 165             av_frame_free(&frame);
 166             return 0;
 167         } else if (ret < 0) {
 168             fprintf(stderr, "Error while decoding. Error code: %s\n", av_err2str(ret));
 169             goto fail;
 170         }
 171
 172         if (!initialized) {
 173             /* we need to ref hw_frames_ctx of decoder to initialize encoder's codec.
 174                Only after we get a decoded frame, can we obtain its hw_frames_ctx */
 175             encoder_ctx->hw_frames_ctx = av_buffer_ref(decoder_ctx->hw_frames_ctx);
 176             if (!encoder_ctx->hw_frames_ctx) {
 177                 ret = AVERROR(ENOMEM);
 178                 goto fail;
 179             }
 180             /* set AVCodecContext Parameters for encoder, here we keep them stay
 181              * the same as decoder.
 182              * xxx: now the the sample can't handle resolution change case.
 183              */
 184             encoder_ctx->time_base = av_inv_q(decoder_ctx->framerate);
 185             encoder_ctx->pix_fmt   = AV_PIX_FMT_VAAPI;
 186             encoder_ctx->width     = decoder_ctx->width;
 187             encoder_ctx->height    = decoder_ctx->height;
 188
 189             if ((ret = avcodec_open2(encoder_ctx, enc_codec, NULL)) < 0) {
 190                 fprintf(stderr, "Failed to open encode codec. Error code: %s\n",
 191                         av_err2str(ret));
 192                 goto fail;
 193             }
 194
 195             if (!(ost = avformat_new_stream(ofmt_ctx, enc_codec))) {
 196                 fprintf(stderr, "Failed to allocate stream for output format.\n");
 197                 ret = AVERROR(ENOMEM);
 198                 goto fail;
 199             }
 200
 201             ost->time_base = encoder_ctx->time_base;
 202             ret = avcodec_parameters_from_context(ost->codecpar, encoder_ctx);
 203             if (ret < 0) {
 204                 fprintf(stderr, "Failed to copy the stream parameters. "
 205                         "Error code: %s\n", av_err2str(ret));
 206                 goto fail;
 207             }
 208
 209             /* write the stream header */
 210             if ((ret = avformat_write_header(ofmt_ctx, NULL)) < 0) {
 211                 fprintf(stderr, "Error while writing stream header. "
 212                         "Error code: %s\n", av_err2str(ret));
 213                 goto fail;
 214             }
 215
 216             initialized = 1;
 217         }
 218
 219         if ((ret = encode_write(frame)) < 0)
 220             fprintf(stderr, "Error during encoding and writing.\n");
 221
 222 fail:
 223         av_frame_free(&frame);
 224         if (ret < 0)
 225             return ret;
 226     }
 227     return 0;
 228 }
 229
 230 int main(int argc, char **argv)
 231 {
 232     int ret = 0;
 233     AVPacket dec_pkt;
 234     AVCodec *enc_codec;
 235
 236     if (argc != 4) {
 237         fprintf(stderr, "Usage: %s <input file> <encode codec> <output file>\n"
 238                 "The output format is guessed according to the file extension.\n"
 239                 "\n", argv[0]);
 240         return -1;
 241     }
 242
 243     ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI, NULL, NULL, 0);
 244     if (ret < 0) {
 245         fprintf(stderr, "Failed to create a VAAPI device. Error code: %s\n", av_err2str(ret));
 246         return -1;
 247     }
 248
 249     if ((ret = open_input_file(argv[1])) < 0)
 250         goto end;
 251
 252     if (!(enc_codec = avcodec_find_encoder_by_name(argv[2]))) {
 253         fprintf(stderr, "Could not find encoder '%s'\n", argv[2]);
 254         ret = -1;
 255         goto end;
 256     }
 257
 258     if ((ret = (avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, argv[3]))) < 0) {
 259         fprintf(stderr, "Failed to deduce output format from file extension. Error code: "
 260                 "%s\n", av_err2str(ret));
 261         goto end;
 262     }
 263
 264     if (!(encoder_ctx = avcodec_alloc_context3(enc_codec))) {
 265         ret = AVERROR(ENOMEM);
 266         goto end;
 267     }
 268
 269     ret = avio_open(&ofmt_ctx->pb, argv[3], AVIO_FLAG_WRITE);
 270     if (ret < 0) {
 271         fprintf(stderr, "Cannot open output file. "
 272                 "Error code: %s\n", av_err2str(ret));
 273         goto end;
 274     }
 275
 276     /* read all packets and only transcoding video */
 277     while (ret >= 0) {
 278         if ((ret = av_read_frame(ifmt_ctx, &dec_pkt)) < 0)
 279             break;
 280
 281         if (video_stream == dec_pkt.stream_index)
 282             ret = dec_enc(&dec_pkt, enc_codec);
 283
 284         av_packet_unref(&dec_pkt);
 285     }
 286
 287     /* flush decoder */
 288     dec_pkt.data = NULL;
 289     dec_pkt.size = 0;
 290     ret = dec_enc(&dec_pkt, enc_codec);
 291     av_packet_unref(&dec_pkt);
 292
 293     /* flush encoder */
 294     ret = encode_write(NULL);
 295
 296     /* write the trailer for output stream */
 297     av_write_trailer(ofmt_ctx);
 298
 299 end:
 300     avformat_close_input(&ifmt_ctx);
 301     avformat_close_input(&ofmt_ctx);
 302     avcodec_free_context(&decoder_ctx);
 303     avcodec_free_context(&encoder_ctx);
 304     av_buffer_unref(&hw_device_ctx);
 305     return ret;
 306 }