git.sesse.net Git - ffmpeg/blob - libavcodec/qsvdec.c

   1 /*
   2  * Intel MediaSDK QSV codec-independent code
   3  *
   4  * copyright (c) 2013 Luca Barbato
   5  * copyright (c) 2015 Anton Khirnov <anton@khirnov.net>
   6  *
   7  * This file is part of FFmpeg.
   8  *
   9  * FFmpeg is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * FFmpeg is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with FFmpeg; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 #include <string.h>
  25 #include <sys/types.h>
  26
  27 #include <mfx/mfxvideo.h>
  28
  29 #include "libavutil/common.h"
  30 #include "libavutil/mem.h"
  31 #include "libavutil/log.h"
  32 #include "libavutil/pixfmt.h"
  33 #include "libavutil/time.h"
  34
  35 #include "avcodec.h"
  36 #include "internal.h"
  37 #include "qsv.h"
  38 #include "qsv_internal.h"
  39 #include "qsvdec.h"
  40
  41 int ff_qsv_map_pixfmt(enum AVPixelFormat format)
  42 {
  43     switch (format) {
  44     case AV_PIX_FMT_YUV420P:
  45     case AV_PIX_FMT_YUVJ420P:
  46         return AV_PIX_FMT_NV12;
  47     default:
  48         return AVERROR(ENOSYS);
  49     }
  50 }
  51
  52 static int qsv_decode_init(AVCodecContext *avctx, QSVContext *q, AVPacket *avpkt)
  53 {
  54     mfxVideoParam param = { { 0 } };
  55     mfxBitstream bs   = { { { 0 } } };
  56     int ret;
  57     enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_QSV,
  58                                        AV_PIX_FMT_NV12,
  59                                        AV_PIX_FMT_NONE };
  60
  61     ret = ff_get_format(avctx, pix_fmts);
  62     if (ret < 0)
  63         return ret;
  64
  65     avctx->pix_fmt      = ret;
  66
  67     q->iopattern  = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
  68     if (avctx->hwaccel_context) {
  69         AVQSVContext *qsv = avctx->hwaccel_context;
  70
  71         q->session        = qsv->session;
  72         q->iopattern      = qsv->iopattern;
  73         q->ext_buffers    = qsv->ext_buffers;
  74         q->nb_ext_buffers = qsv->nb_ext_buffers;
  75     }
  76     if (!q->session) {
  77         if (!q->internal_qs.session) {
  78             ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,
  79                                                q->load_plugins);
  80             if (ret < 0)
  81                 return ret;
  82         }
  83
  84         q->session = q->internal_qs.session;
  85     }
  86
  87     if (avpkt->size) {
  88         bs.Data       = avpkt->data;
  89         bs.DataLength = avpkt->size;
  90         bs.MaxLength  = bs.DataLength;
  91         bs.TimeStamp  = avpkt->pts;
  92     } else
  93         return AVERROR_INVALIDDATA;
  94
  95     ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
  96     if (ret < 0) {
  97         av_log(avctx, AV_LOG_ERROR, "Unsupported codec_id %08x\n", avctx->codec_id);
  98         return ret;
  99     }
 100
 101     param.mfx.CodecId = ret;
 102
 103     ret = MFXVideoDECODE_DecodeHeader(q->session, &bs, &param);
 104     if (MFX_ERR_MORE_DATA==ret) {
 105         /* this code means that header not found so we return packet size to skip
 106            a current packet
 107          */
 108         return avpkt->size;
 109     } else if (ret < 0) {
 110         av_log(avctx, AV_LOG_ERROR, "Decode header error %d\n", ret);
 111         return ff_qsv_error(ret);
 112     }
 113     param.IOPattern   = q->iopattern;
 114     param.AsyncDepth  = q->async_depth;
 115     param.ExtParam    = q->ext_buffers;
 116     param.NumExtParam = q->nb_ext_buffers;
 117     param.mfx.FrameInfo.BitDepthLuma   = 8;
 118     param.mfx.FrameInfo.BitDepthChroma = 8;
 119
 120     ret = MFXVideoDECODE_Init(q->session, &param);
 121     if (ret < 0) {
 122         if (MFX_ERR_INVALID_VIDEO_PARAM==ret) {
 123             av_log(avctx, AV_LOG_ERROR,
 124                    "Error initializing the MFX video decoder, unsupported video\n");
 125         } else {
 126             av_log(avctx, AV_LOG_ERROR,
 127                    "Error initializing the MFX video decoder %d\n", ret);
 128         }
 129         return ff_qsv_error(ret);
 130     }
 131
 132     avctx->profile      = param.mfx.CodecProfile;
 133     avctx->level        = param.mfx.CodecLevel;
 134     avctx->coded_width  = param.mfx.FrameInfo.Width;
 135     avctx->coded_height = param.mfx.FrameInfo.Height;
 136     avctx->width        = param.mfx.FrameInfo.CropW - param.mfx.FrameInfo.CropX;
 137     avctx->height       = param.mfx.FrameInfo.CropH - param.mfx.FrameInfo.CropY;
 138
 139     /* maximum decoder latency should be not exceed max DPB size for h.264 and
 140        HEVC which is 16 for both cases.
 141        So weare  pre-allocating fifo big enough for 17 elements:
 142      */
 143     if (!q->async_fifo) {
 144         q->async_fifo = av_fifo_alloc((1 + 16) *
 145                                       (sizeof(mfxSyncPoint) + sizeof(QSVFrame*)));
 146         if (!q->async_fifo)
 147             return AVERROR(ENOMEM);
 148     }
 149
 150     if (!q->input_fifo) {
 151         q->input_fifo = av_fifo_alloc(1024*16);
 152         if (!q->input_fifo)
 153             return AVERROR(ENOMEM);
 154     }
 155
 156     if (!q->pkt_fifo) {
 157         q->pkt_fifo = av_fifo_alloc( sizeof(AVPacket) * (1 + 16) );
 158         if (!q->pkt_fifo)
 159             return AVERROR(ENOMEM);
 160     }
 161     q->engine_ready = 1;
 162
 163     return 0;
 164 }
 165
 166 static int alloc_frame(AVCodecContext *avctx, QSVFrame *frame)
 167 {
 168     int ret;
 169
 170     ret = ff_get_buffer(avctx, frame->frame, AV_GET_BUFFER_FLAG_REF);
 171     if (ret < 0)
 172         return ret;
 173
 174     if (frame->frame->format == AV_PIX_FMT_QSV) {
 175         frame->surface = (mfxFrameSurface1*)frame->frame->data[3];
 176     } else {
 177         frame->surface_internal.Info.BitDepthLuma   = 8;
 178         frame->surface_internal.Info.BitDepthChroma = 8;
 179         frame->surface_internal.Info.FourCC         = MFX_FOURCC_NV12;
 180         frame->surface_internal.Info.Width          = avctx->coded_width;
 181         frame->surface_internal.Info.Height         = avctx->coded_height;
 182         frame->surface_internal.Info.ChromaFormat   = MFX_CHROMAFORMAT_YUV420;
 183
 184         frame->surface_internal.Data.PitchLow = frame->frame->linesize[0];
 185         frame->surface_internal.Data.Y        = frame->frame->data[0];
 186         frame->surface_internal.Data.UV       = frame->frame->data[1];
 187
 188         frame->surface = &frame->surface_internal;
 189     }
 190
 191     return 0;
 192 }
 193
 194 static void qsv_clear_unused_frames(QSVContext *q)
 195 {
 196     QSVFrame *cur = q->work_frames;
 197     while (cur) {
 198         if (cur->surface && !cur->surface->Data.Locked && !cur->queued) {
 199             cur->surface = NULL;
 200             av_frame_unref(cur->frame);
 201         }
 202         cur = cur->next;
 203     }
 204 }
 205
 206 static int get_surface(AVCodecContext *avctx, QSVContext *q, mfxFrameSurface1 **surf)
 207 {
 208     QSVFrame *frame, **last;
 209     int ret;
 210
 211     qsv_clear_unused_frames(q);
 212
 213     frame = q->work_frames;
 214     last  = &q->work_frames;
 215     while (frame) {
 216         if (!frame->surface) {
 217             ret = alloc_frame(avctx, frame);
 218             if (ret < 0)
 219                 return ret;
 220             *surf = frame->surface;
 221             return 0;
 222         }
 223
 224         last  = &frame->next;
 225         frame = frame->next;
 226     }
 227
 228     frame = av_mallocz(sizeof(*frame));
 229     if (!frame)
 230         return AVERROR(ENOMEM);
 231     frame->frame = av_frame_alloc();
 232     if (!frame->frame) {
 233         av_freep(&frame);
 234         return AVERROR(ENOMEM);
 235     }
 236     *last = frame;
 237
 238     ret = alloc_frame(avctx, frame);
 239     if (ret < 0)
 240         return ret;
 241
 242     *surf = frame->surface;
 243
 244     return 0;
 245 }
 246
 247 static QSVFrame *find_frame(QSVContext *q, mfxFrameSurface1 *surf)
 248 {
 249     QSVFrame *cur = q->work_frames;
 250     while (cur) {
 251         if (surf == cur->surface)
 252             return cur;
 253         cur = cur->next;
 254     }
 255     return NULL;
 256 }
 257
 258 /*  This function uses for 'smart' releasing of consumed data
 259     from the input bitstream fifo.
 260     Since the input fifo mapped to mfxBitstream which does not understand
 261     a wrapping of data over fifo end, we should also to relocate a possible
 262     data rest to fifo begin. If rest of data is absent then we just reset fifo's
 263     pointers to initial positions.
 264     NOTE the case when fifo does contain unconsumed data is rare and typical
 265     amount of such data is 1..4 bytes.
 266 */
 267 static void qsv_fifo_relocate(AVFifoBuffer *f, int bytes_to_free)
 268 {
 269     int data_size;
 270     int data_rest = 0;
 271
 272     av_fifo_drain(f, bytes_to_free);
 273
 274     data_size = av_fifo_size(f);
 275     if (data_size > 0) {
 276         if (f->buffer!=f->rptr) {
 277             if ( (f->end - f->rptr) < data_size) {
 278                 data_rest = data_size - (f->end - f->rptr);
 279                 data_size-=data_rest;
 280                 memmove(f->buffer+data_size, f->buffer, data_rest);
 281             }
 282             memmove(f->buffer, f->rptr, data_size);
 283             data_size+= data_rest;
 284         }
 285     }
 286     f->rptr = f->buffer;
 287     f->wptr = f->buffer + data_size;
 288     f->wndx = data_size;
 289     f->rndx = 0;
 290 }
 291
 292
 293 static void close_decoder(QSVContext *q)
 294 {
 295     QSVFrame *cur;
 296
 297     if (q->session)
 298         MFXVideoDECODE_Close(q->session);
 299
 300     cur = q->work_frames;
 301     while (cur) {
 302         q->work_frames = cur->next;
 303         av_frame_free(&cur->frame);
 304         av_freep(&cur);
 305         cur = q->work_frames;
 306     }
 307
 308     q->engine_ready   = 0;
 309     q->reinit_pending = 0;
 310 }
 311
 312 static int do_qsv_decode(AVCodecContext *avctx, QSVContext *q,
 313                   AVFrame *frame, int *got_frame,
 314                   AVPacket *avpkt)
 315 {
 316     QSVFrame *out_frame;
 317     mfxFrameSurface1 *insurf;
 318     mfxFrameSurface1 *outsurf;
 319     mfxSyncPoint sync;
 320     mfxBitstream bs = { { { 0 } } };
 321     int ret;
 322     int n_out_frames;
 323     int buffered = 0;
 324     int flush    = !avpkt->size || q->reinit_pending;
 325
 326     if (!q->engine_ready) {
 327         ret = qsv_decode_init(avctx, q, avpkt);
 328         if (ret)
 329             return ret;
 330     }
 331
 332     if (!flush) {
 333         if (av_fifo_size(q->input_fifo)) {
 334             /* we have got rest of previous packet into buffer */
 335             if (av_fifo_space(q->input_fifo) < avpkt->size) {
 336                 ret = av_fifo_grow(q->input_fifo, avpkt->size);
 337                 if (ret < 0)
 338                     return ret;
 339             }
 340             av_fifo_generic_write(q->input_fifo, avpkt->data, avpkt->size, NULL);
 341             bs.Data       = q->input_fifo->rptr;
 342             bs.DataLength = av_fifo_size(q->input_fifo);
 343             buffered = 1;
 344         } else {
 345             bs.Data       = avpkt->data;
 346             bs.DataLength = avpkt->size;
 347         }
 348         bs.MaxLength  = bs.DataLength;
 349         bs.TimeStamp  = avpkt->pts;
 350     }
 351
 352     while (1) {
 353         ret = get_surface(avctx, q, &insurf);
 354         if (ret < 0)
 355             return ret;
 356         do {
 357             ret = MFXVideoDECODE_DecodeFrameAsync(q->session, flush ? NULL : &bs,
 358                                                   insurf, &outsurf, &sync);
 359             if (ret != MFX_WRN_DEVICE_BUSY)
 360                 break;
 361             av_usleep(500);
 362         } while (1);
 363
 364         if (MFX_WRN_VIDEO_PARAM_CHANGED==ret) {
 365             /* TODO: handle here minor sequence header changing */
 366         } else if (MFX_ERR_INCOMPATIBLE_VIDEO_PARAM==ret) {
 367             av_fifo_reset(q->input_fifo);
 368             flush = q->reinit_pending = 1;
 369             continue;
 370         }
 371
 372         if (sync) {
 373             QSVFrame *out_frame = find_frame(q, outsurf);
 374
 375             if (!out_frame) {
 376                 av_log(avctx, AV_LOG_ERROR,
 377                        "The returned surface does not correspond to any frame\n");
 378                 return AVERROR_BUG;
 379             }
 380
 381             out_frame->queued = 1;
 382             av_fifo_generic_write(q->async_fifo, &out_frame, sizeof(out_frame), NULL);
 383             av_fifo_generic_write(q->async_fifo, &sync,      sizeof(sync),      NULL);
 384
 385             continue;
 386         }
 387         if (MFX_ERR_MORE_SURFACE != ret && ret < 0)
 388             break;
 389     }
 390
 391     /* make sure we do not enter an infinite loop if the SDK
 392      * did not consume any data and did not return anything */
 393     if (!sync && !bs.DataOffset && !flush) {
 394         av_log(avctx, AV_LOG_WARNING, "A decode call did not consume any data\n");
 395         bs.DataOffset = avpkt->size;
 396     }
 397
 398     if (buffered) {
 399         qsv_fifo_relocate(q->input_fifo, bs.DataOffset);
 400     } else if (bs.DataOffset!=avpkt->size) {
 401         /* some data of packet was not consumed. store it to local buffer */
 402         av_fifo_generic_write(q->input_fifo, avpkt->data+bs.DataOffset,
 403                               avpkt->size - bs.DataOffset, NULL);
 404     }
 405
 406     if (MFX_ERR_MORE_DATA!=ret && ret < 0) {
 407         av_log(avctx, AV_LOG_ERROR, "Error %d during QSV decoding.\n", ret);
 408         return ff_qsv_error(ret);
 409     }
 410     n_out_frames = av_fifo_size(q->async_fifo) / (sizeof(out_frame)+sizeof(sync));
 411
 412     if (n_out_frames > q->async_depth || (flush && n_out_frames) ) {
 413         AVFrame *src_frame;
 414
 415         av_fifo_generic_read(q->async_fifo, &out_frame, sizeof(out_frame), NULL);
 416         av_fifo_generic_read(q->async_fifo, &sync,      sizeof(sync),      NULL);
 417         out_frame->queued = 0;
 418
 419         MFXVideoCORE_SyncOperation(q->session, sync, 60000);
 420
 421         src_frame = out_frame->frame;
 422
 423         ret = av_frame_ref(frame, src_frame);
 424         if (ret < 0)
 425             return ret;
 426
 427         outsurf = out_frame->surface;
 428
 429         frame->pkt_pts = frame->pts = outsurf->Data.TimeStamp;
 430
 431         frame->repeat_pict =
 432             outsurf->Info.PicStruct & MFX_PICSTRUCT_FRAME_TRIPLING ? 4 :
 433             outsurf->Info.PicStruct & MFX_PICSTRUCT_FRAME_DOUBLING ? 2 :
 434             outsurf->Info.PicStruct & MFX_PICSTRUCT_FIELD_REPEATED ? 1 : 0;
 435         frame->top_field_first =
 436             outsurf->Info.PicStruct & MFX_PICSTRUCT_FIELD_TFF;
 437         frame->interlaced_frame =
 438             !(outsurf->Info.PicStruct & MFX_PICSTRUCT_PROGRESSIVE);
 439
 440         *got_frame = 1;
 441     }
 442
 443     return avpkt->size;
 444 }
 445 /*
 446  This function inserts a packet at fifo front.
 447 */
 448 static void qsv_packet_push_front(QSVContext *q, AVPacket *avpkt)
 449 {
 450     int fifo_size = av_fifo_size(q->pkt_fifo);
 451     if (!fifo_size) {
 452     /* easy case fifo is empty */
 453         av_fifo_generic_write(q->pkt_fifo, avpkt, sizeof(*avpkt), NULL);
 454     } else {
 455     /* realloc necessary */
 456         AVPacket pkt;
 457         AVFifoBuffer *fifo = av_fifo_alloc(fifo_size+av_fifo_space(q->pkt_fifo));
 458
 459         av_fifo_generic_write(fifo, avpkt, sizeof(*avpkt), NULL);
 460
 461         while (av_fifo_size(q->pkt_fifo)) {
 462             av_fifo_generic_read(q->pkt_fifo, &pkt, sizeof(pkt), NULL);
 463             av_fifo_generic_write(fifo,       &pkt, sizeof(pkt), NULL);
 464         }
 465         av_fifo_free(q->pkt_fifo);
 466         q->pkt_fifo = fifo;
 467     }
 468 }
 469 int ff_qsv_decode(AVCodecContext *avctx, QSVContext *q,
 470                   AVFrame *frame, int *got_frame,
 471                   AVPacket *avpkt)
 472 {
 473     AVPacket pkt_ref = { 0 };
 474     int ret = 0;
 475
 476     if (q->pkt_fifo && av_fifo_size(q->pkt_fifo) >= sizeof(AVPacket)) {
 477         /* we already have got some buffered packets. so add new to tail */
 478         ret = av_packet_ref(&pkt_ref, avpkt);
 479         if (ret < 0)
 480             return ret;
 481         av_fifo_generic_write(q->pkt_fifo, &pkt_ref, sizeof(pkt_ref), NULL);
 482     }
 483     if (q->reinit_pending) {
 484         ret = do_qsv_decode(avctx, q, frame, got_frame, avpkt);
 485
 486         if (!*got_frame) {
 487             /* Flushing complete, no more frames  */
 488             close_decoder(q);
 489             //return ff_qsv_decode(avctx, q, frame, got_frame, avpkt);
 490         }
 491     }
 492     if (!q->reinit_pending) {
 493         if (q->pkt_fifo && av_fifo_size(q->pkt_fifo) >= sizeof(AVPacket)) {
 494             /* process buffered packets */
 495             while (!*got_frame && av_fifo_size(q->pkt_fifo) >= sizeof(AVPacket)) {
 496                 av_fifo_generic_read(q->pkt_fifo, &pkt_ref, sizeof(pkt_ref), NULL);
 497                 ret = do_qsv_decode(avctx, q, frame, got_frame, &pkt_ref);
 498                 if (q->reinit_pending) {
 499                     /*
 500                        A rare case: new reinit pending when buffering existing.
 501                        We should to return the pkt_ref back to same place of fifo
 502                     */
 503                     qsv_packet_push_front(q, &pkt_ref);
 504                 } else {
 505                     av_packet_unref(&pkt_ref);
 506                 }
 507            }
 508         } else {
 509             /* general decoding */
 510             ret = do_qsv_decode(avctx, q, frame, got_frame, avpkt);
 511             if (q->reinit_pending) {
 512                 ret = av_packet_ref(&pkt_ref, avpkt);
 513                 if (ret < 0)
 514                     return ret;
 515                 av_fifo_generic_write(q->pkt_fifo, &pkt_ref, sizeof(pkt_ref), NULL);
 516             }
 517         }
 518     }
 519
 520     return ret;
 521 }
 522 /*
 523  This function resets decoder and corresponded buffers before seek operation
 524 */
 525 void ff_qsv_decode_reset(AVCodecContext *avctx, QSVContext *q)
 526 {
 527     QSVFrame *cur;
 528     AVPacket pkt;
 529     int ret = 0;
 530     mfxVideoParam param = { { 0 } };
 531
 532     if (q->reinit_pending) {
 533         close_decoder(q);
 534     } else if (q->engine_ready) {
 535         ret = MFXVideoDECODE_GetVideoParam(q->session, &param);
 536         if (ret < 0) {
 537             av_log(avctx, AV_LOG_ERROR, "MFX decode get param error %d\n", ret);
 538         }
 539
 540         ret = MFXVideoDECODE_Reset(q->session, &param);
 541         if (ret < 0) {
 542             av_log(avctx, AV_LOG_ERROR, "MFX decode reset error %d\n", ret);
 543         }
 544
 545         /* Free all frames*/
 546         cur = q->work_frames;
 547         while (cur) {
 548             q->work_frames = cur->next;
 549             av_frame_free(&cur->frame);
 550             av_freep(&cur);
 551             cur = q->work_frames;
 552         }
 553     }
 554
 555     /* Reset output surfaces */
 556     av_fifo_reset(q->async_fifo);
 557
 558     /* Reset input packets fifo */
 559     while (av_fifo_size(q->pkt_fifo)) {
 560         av_fifo_generic_read(q->pkt_fifo, &pkt, sizeof(pkt), NULL);
 561         av_packet_unref(&pkt);
 562     }
 563
 564     /* Reset input bitstream fifo */
 565     av_fifo_reset(q->input_fifo);
 566 }
 567
 568 int ff_qsv_decode_close(QSVContext *q)
 569 {
 570     close_decoder(q);
 571
 572     q->session = NULL;
 573
 574     ff_qsv_close_internal_session(&q->internal_qs);
 575
 576     av_fifo_free(q->async_fifo);
 577     q->async_fifo = NULL;
 578
 579     av_fifo_free(q->input_fifo);
 580     q->input_fifo = NULL;
 581
 582     av_fifo_free(q->pkt_fifo);
 583     q->pkt_fifo = NULL;
 584
 585     return 0;
 586 }