Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Video Decode and Presentation API for UNIX (VDPAU) is used for
  3.  * HW decode acceleration for MPEG-1/2, MPEG-4 ASP, H.264 and VC-1.
  4.  *
  5.  * Copyright (c) 2008 NVIDIA
  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 <limits.h>
  25. #include "libavutil/avassert.h"
  26. #include "avcodec.h"
  27. #include "internal.h"
  28. #include "h264.h"
  29. #include "vc1.h"
  30.  
  31. #undef NDEBUG
  32. #include <assert.h>
  33.  
  34. #include "vdpau.h"
  35. #include "vdpau_compat.h"
  36. #include "vdpau_internal.h"
  37.  
  38. /**
  39.  * @addtogroup VDPAU_Decoding
  40.  *
  41.  * @{
  42.  */
  43.  
  44. static int vdpau_error(VdpStatus status)
  45. {
  46.     switch (status) {
  47.     case VDP_STATUS_OK:
  48.         return 0;
  49.     case VDP_STATUS_NO_IMPLEMENTATION:
  50.         return AVERROR(ENOSYS);
  51.     case VDP_STATUS_DISPLAY_PREEMPTED:
  52.         return AVERROR(EIO);
  53.     case VDP_STATUS_INVALID_HANDLE:
  54.         return AVERROR(EBADF);
  55.     case VDP_STATUS_INVALID_POINTER:
  56.         return AVERROR(EFAULT);
  57.     case VDP_STATUS_RESOURCES:
  58.         return AVERROR(ENOBUFS);
  59.     case VDP_STATUS_HANDLE_DEVICE_MISMATCH:
  60.         return AVERROR(EXDEV);
  61.     case VDP_STATUS_ERROR:
  62.         return AVERROR(EIO);
  63.     default:
  64.         return AVERROR(EINVAL);
  65.     }
  66. }
  67.  
  68. AVVDPAUContext *av_alloc_vdpaucontext(void)
  69. {
  70.     return av_vdpau_alloc_context();
  71. }
  72.  
  73. MAKE_ACCESSORS(AVVDPAUContext, vdpau_hwaccel, AVVDPAU_Render2, render2)
  74.  
  75. int av_vdpau_get_surface_parameters(AVCodecContext *avctx,
  76.                                     VdpChromaType *type,
  77.                                     uint32_t *width, uint32_t *height)
  78. {
  79.     VdpChromaType t;
  80.     uint32_t w = avctx->coded_width;
  81.     uint32_t h = avctx->coded_height;
  82.  
  83.     /* See <vdpau/vdpau.h> for per-type alignment constraints. */
  84.     switch (avctx->sw_pix_fmt) {
  85.     case AV_PIX_FMT_YUV420P:
  86.     case AV_PIX_FMT_YUVJ420P:
  87.         t = VDP_CHROMA_TYPE_420;
  88.         w = (w + 1) & ~1;
  89.         h = (h + 3) & ~3;
  90.         break;
  91.     case AV_PIX_FMT_YUV422P:
  92.     case AV_PIX_FMT_YUVJ422P:
  93.         t = VDP_CHROMA_TYPE_422;
  94.         w = (w + 1) & ~1;
  95.         h = (h + 1) & ~1;
  96.         break;
  97.     case AV_PIX_FMT_YUV444P:
  98.     case AV_PIX_FMT_YUVJ444P:
  99.         t = VDP_CHROMA_TYPE_444;
  100.         h = (h + 1) & ~1;
  101.         break;
  102.     default:
  103.         return AVERROR(ENOSYS);
  104.     }
  105.  
  106.     if (type)
  107.         *type = t;
  108.     if (width)
  109.         *width = w;
  110.     if (height)
  111.         *height = h;
  112.     return 0;
  113. }
  114.  
  115. int ff_vdpau_common_init(AVCodecContext *avctx, VdpDecoderProfile profile,
  116.                          int level)
  117. {
  118.     VDPAUHWContext *hwctx = avctx->hwaccel_context;
  119.     VDPAUContext *vdctx = avctx->internal->hwaccel_priv_data;
  120.     VdpVideoSurfaceQueryCapabilities *surface_query_caps;
  121.     VdpDecoderQueryCapabilities *decoder_query_caps;
  122.     VdpDecoderCreate *create;
  123.     void *func;
  124.     VdpStatus status;
  125.     VdpBool supported;
  126.     uint32_t max_level, max_mb, max_width, max_height;
  127.     VdpChromaType type;
  128.     uint32_t width;
  129.     uint32_t height;
  130.  
  131.     vdctx->width            = UINT32_MAX;
  132.     vdctx->height           = UINT32_MAX;
  133.  
  134.     if (!hwctx) {
  135.         vdctx->device  = VDP_INVALID_HANDLE;
  136.         av_log(avctx, AV_LOG_WARNING, "hwaccel_context has not been setup by the user application, cannot initialize\n");
  137.         return 0;
  138.     }
  139.  
  140.     if (hwctx->context.decoder != VDP_INVALID_HANDLE) {
  141.         vdctx->decoder = hwctx->context.decoder;
  142.         vdctx->render  = hwctx->context.render;
  143.         vdctx->device  = VDP_INVALID_HANDLE;
  144.         return 0; /* Decoder created by user */
  145.     }
  146.     hwctx->reset            = 0;
  147.  
  148.     vdctx->device           = hwctx->device;
  149.     vdctx->get_proc_address = hwctx->get_proc_address;
  150.  
  151.     if (hwctx->flags & AV_HWACCEL_FLAG_IGNORE_LEVEL)
  152.         level = 0;
  153.     else if (level < 0)
  154.         return AVERROR(ENOTSUP);
  155.  
  156.     if (av_vdpau_get_surface_parameters(avctx, &type, &width, &height))
  157.         return AVERROR(ENOSYS);
  158.  
  159.     if (!(hwctx->flags & AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH) &&
  160.         type != VDP_CHROMA_TYPE_420)
  161.         return AVERROR(ENOSYS);
  162.  
  163.     status = vdctx->get_proc_address(vdctx->device,
  164.                                      VDP_FUNC_ID_VIDEO_SURFACE_QUERY_CAPABILITIES,
  165.                                      &func);
  166.     if (status != VDP_STATUS_OK)
  167.         return vdpau_error(status);
  168.     else
  169.         surface_query_caps = func;
  170.  
  171.     status = surface_query_caps(vdctx->device, type, &supported,
  172.                                 &max_width, &max_height);
  173.     if (status != VDP_STATUS_OK)
  174.         return vdpau_error(status);
  175.     if (supported != VDP_TRUE ||
  176.         max_width < width || max_height < height)
  177.         return AVERROR(ENOTSUP);
  178.  
  179.     status = vdctx->get_proc_address(vdctx->device,
  180.                                      VDP_FUNC_ID_DECODER_QUERY_CAPABILITIES,
  181.                                      &func);
  182.     if (status != VDP_STATUS_OK)
  183.         return vdpau_error(status);
  184.     else
  185.         decoder_query_caps = func;
  186.  
  187.     status = decoder_query_caps(vdctx->device, profile, &supported, &max_level,
  188.                                 &max_mb, &max_width, &max_height);
  189. #ifdef VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE
  190.     if (status != VDP_STATUS_OK && profile == VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE) {
  191.         /* Run-time backward compatibility for libvdpau 0.8 and earlier */
  192.         profile = VDP_DECODER_PROFILE_H264_MAIN;
  193.         status = decoder_query_caps(vdctx->device, profile, &supported,
  194.                                     &max_level, &max_mb,
  195.                                     &max_width, &max_height);
  196.     }
  197. #endif
  198.     if (status != VDP_STATUS_OK)
  199.         return vdpau_error(status);
  200.  
  201.     if (supported != VDP_TRUE || max_level < level ||
  202.         max_width < width || max_height < height)
  203.         return AVERROR(ENOTSUP);
  204.  
  205.     status = vdctx->get_proc_address(vdctx->device, VDP_FUNC_ID_DECODER_CREATE,
  206.                                      &func);
  207.     if (status != VDP_STATUS_OK)
  208.         return vdpau_error(status);
  209.     else
  210.         create = func;
  211.  
  212.     status = vdctx->get_proc_address(vdctx->device, VDP_FUNC_ID_DECODER_RENDER,
  213.                                      &func);
  214.     if (status != VDP_STATUS_OK)
  215.         return vdpau_error(status);
  216.     else
  217.         vdctx->render = func;
  218.  
  219.     status = create(vdctx->device, profile, width, height, avctx->refs,
  220.                     &vdctx->decoder);
  221.     if (status == VDP_STATUS_OK) {
  222.         vdctx->width  = avctx->coded_width;
  223.         vdctx->height = avctx->coded_height;
  224.     }
  225.  
  226.     return vdpau_error(status);
  227. }
  228.  
  229. int ff_vdpau_common_uninit(AVCodecContext *avctx)
  230. {
  231.     VDPAUContext *vdctx = avctx->internal->hwaccel_priv_data;
  232.     VdpDecoderDestroy *destroy;
  233.     void *func;
  234.     VdpStatus status;
  235.  
  236.     if (vdctx->device == VDP_INVALID_HANDLE)
  237.         return 0; /* Decoder created and destroyed by user */
  238.     if (vdctx->width == UINT32_MAX && vdctx->height == UINT32_MAX)
  239.         return 0;
  240.  
  241.     status = vdctx->get_proc_address(vdctx->device,
  242.                                      VDP_FUNC_ID_DECODER_DESTROY, &func);
  243.     if (status != VDP_STATUS_OK)
  244.         return vdpau_error(status);
  245.     else
  246.         destroy = func;
  247.  
  248.     status = destroy(vdctx->decoder);
  249.     return vdpau_error(status);
  250. }
  251.  
  252. static int ff_vdpau_common_reinit(AVCodecContext *avctx)
  253. {
  254.     VDPAUHWContext *hwctx = avctx->hwaccel_context;
  255.     VDPAUContext *vdctx = avctx->internal->hwaccel_priv_data;
  256.  
  257.     if (vdctx->device == VDP_INVALID_HANDLE)
  258.         return 0; /* Decoder created by user */
  259.     if (avctx->coded_width == vdctx->width &&
  260.         avctx->coded_height == vdctx->height && !hwctx->reset)
  261.         return 0;
  262.  
  263.     avctx->hwaccel->uninit(avctx);
  264.     return avctx->hwaccel->init(avctx);
  265. }
  266.  
  267. int ff_vdpau_common_start_frame(struct vdpau_picture_context *pic_ctx,
  268.                                 av_unused const uint8_t *buffer,
  269.                                 av_unused uint32_t size)
  270. {
  271.     pic_ctx->bitstream_buffers_allocated = 0;
  272.     pic_ctx->bitstream_buffers_used      = 0;
  273.     pic_ctx->bitstream_buffers           = NULL;
  274.     return 0;
  275. }
  276.  
  277. int ff_vdpau_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
  278.                               struct vdpau_picture_context *pic_ctx)
  279. {
  280.     VDPAUContext *vdctx = avctx->internal->hwaccel_priv_data;
  281.     AVVDPAUContext *hwctx = avctx->hwaccel_context;
  282.     VdpVideoSurface surf = ff_vdpau_get_surface_id(frame);
  283.     VdpStatus status;
  284.     int val;
  285.  
  286.     val = ff_vdpau_common_reinit(avctx);
  287.     if (val < 0)
  288.         return val;
  289.  
  290. #if FF_API_BUFS_VDPAU
  291. FF_DISABLE_DEPRECATION_WARNINGS
  292.     av_assert0(sizeof(hwctx->info) <= sizeof(pic_ctx->info));
  293.     memcpy(&hwctx->info, &pic_ctx->info, sizeof(hwctx->info));
  294.     hwctx->bitstream_buffers = pic_ctx->bitstream_buffers;
  295.     hwctx->bitstream_buffers_used = pic_ctx->bitstream_buffers_used;
  296.     hwctx->bitstream_buffers_allocated = pic_ctx->bitstream_buffers_allocated;
  297. FF_ENABLE_DEPRECATION_WARNINGS
  298. #endif
  299.  
  300.     if (!hwctx->render && hwctx->render2) {
  301.         status = hwctx->render2(avctx, frame, (void *)&pic_ctx->info,
  302.                                 pic_ctx->bitstream_buffers_used, pic_ctx->bitstream_buffers);
  303.     } else
  304.     status = vdctx->render(vdctx->decoder, surf, (void *)&pic_ctx->info,
  305.                            pic_ctx->bitstream_buffers_used,
  306.                            pic_ctx->bitstream_buffers);
  307.  
  308.     av_freep(&pic_ctx->bitstream_buffers);
  309.  
  310. #if FF_API_BUFS_VDPAU
  311. FF_DISABLE_DEPRECATION_WARNINGS
  312.     hwctx->bitstream_buffers = NULL;
  313.     hwctx->bitstream_buffers_used = 0;
  314.     hwctx->bitstream_buffers_allocated = 0;
  315. FF_ENABLE_DEPRECATION_WARNINGS
  316. #endif
  317.  
  318.     return vdpau_error(status);
  319. }
  320.  
  321. #if CONFIG_H263_VDPAU_HWACCEL  || CONFIG_MPEG1_VDPAU_HWACCEL || \
  322.     CONFIG_MPEG2_VDPAU_HWACCEL || CONFIG_MPEG4_VDPAU_HWACCEL || \
  323.     CONFIG_VC1_VDPAU_HWACCEL   || CONFIG_WMV3_VDPAU_HWACCEL
  324. int ff_vdpau_mpeg_end_frame(AVCodecContext *avctx)
  325. {
  326.     MpegEncContext *s = avctx->priv_data;
  327.     Picture *pic = s->current_picture_ptr;
  328.     struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;
  329.     int val;
  330.  
  331.     val = ff_vdpau_common_end_frame(avctx, pic->f, pic_ctx);
  332.     if (val < 0)
  333.         return val;
  334.  
  335.     ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);
  336.     return 0;
  337. }
  338. #endif
  339.  
  340. int ff_vdpau_add_buffer(struct vdpau_picture_context *pic_ctx,
  341.                         const uint8_t *buf, uint32_t size)
  342. {
  343.     VdpBitstreamBuffer *buffers = pic_ctx->bitstream_buffers;
  344.  
  345.     buffers = av_fast_realloc(buffers, &pic_ctx->bitstream_buffers_allocated,
  346.                               (pic_ctx->bitstream_buffers_used + 1) * sizeof(*buffers));
  347.     if (!buffers)
  348.         return AVERROR(ENOMEM);
  349.  
  350.     pic_ctx->bitstream_buffers = buffers;
  351.     buffers += pic_ctx->bitstream_buffers_used++;
  352.  
  353.     buffers->struct_version  = VDP_BITSTREAM_BUFFER_VERSION;
  354.     buffers->bitstream       = buf;
  355.     buffers->bitstream_bytes = size;
  356.     return 0;
  357. }
  358.  
  359. /* Obsolete non-hwaccel VDPAU support below... */
  360.  
  361. #if FF_API_VDPAU
  362. void ff_vdpau_add_data_chunk(uint8_t *data, const uint8_t *buf, int buf_size)
  363. {
  364.     struct vdpau_render_state *render = (struct vdpau_render_state*)data;
  365.     assert(render);
  366.  
  367.     render->bitstream_buffers= av_fast_realloc(
  368.         render->bitstream_buffers,
  369.         &render->bitstream_buffers_allocated,
  370.         sizeof(*render->bitstream_buffers)*(render->bitstream_buffers_used + 1)
  371.     );
  372.  
  373.     render->bitstream_buffers[render->bitstream_buffers_used].struct_version  = VDP_BITSTREAM_BUFFER_VERSION;
  374.     render->bitstream_buffers[render->bitstream_buffers_used].bitstream       = buf;
  375.     render->bitstream_buffers[render->bitstream_buffers_used].bitstream_bytes = buf_size;
  376.     render->bitstream_buffers_used++;
  377. }
  378.  
  379. #if CONFIG_H264_VDPAU_DECODER
  380. void ff_vdpau_h264_set_reference_frames(H264Context *h)
  381. {
  382.     struct vdpau_render_state *render, *render_ref;
  383.     VdpReferenceFrameH264 *rf, *rf2;
  384.     H264Picture *pic;
  385.     int i, list, pic_frame_idx;
  386.  
  387.     render = (struct vdpau_render_state *)h->cur_pic_ptr->f->data[0];
  388.     assert(render);
  389.  
  390.     rf = &render->info.h264.referenceFrames[0];
  391. #define H264_RF_COUNT FF_ARRAY_ELEMS(render->info.h264.referenceFrames)
  392.  
  393.     for (list = 0; list < 2; ++list) {
  394.         H264Picture **lp = list ? h->long_ref : h->short_ref;
  395.         int ls = list ? 16 : h->short_ref_count;
  396.  
  397.         for (i = 0; i < ls; ++i) {
  398.             pic = lp[i];
  399.             if (!pic || !pic->reference)
  400.                 continue;
  401.             pic_frame_idx = pic->long_ref ? pic->pic_id : pic->frame_num;
  402.  
  403.             render_ref = (struct vdpau_render_state *)pic->f->data[0];
  404.             assert(render_ref);
  405.  
  406.             rf2 = &render->info.h264.referenceFrames[0];
  407.             while (rf2 != rf) {
  408.                 if (
  409.                     (rf2->surface == render_ref->surface)
  410.                     && (rf2->is_long_term == pic->long_ref)
  411.                     && (rf2->frame_idx == pic_frame_idx)
  412.                 )
  413.                     break;
  414.                 ++rf2;
  415.             }
  416.             if (rf2 != rf) {
  417.                 rf2->top_is_reference    |= (pic->reference & PICT_TOP_FIELD)    ? VDP_TRUE : VDP_FALSE;
  418.                 rf2->bottom_is_reference |= (pic->reference & PICT_BOTTOM_FIELD) ? VDP_TRUE : VDP_FALSE;
  419.                 continue;
  420.             }
  421.  
  422.             if (rf >= &render->info.h264.referenceFrames[H264_RF_COUNT])
  423.                 continue;
  424.  
  425.             rf->surface             = render_ref->surface;
  426.             rf->is_long_term        = pic->long_ref;
  427.             rf->top_is_reference    = (pic->reference & PICT_TOP_FIELD)    ? VDP_TRUE : VDP_FALSE;
  428.             rf->bottom_is_reference = (pic->reference & PICT_BOTTOM_FIELD) ? VDP_TRUE : VDP_FALSE;
  429.             rf->field_order_cnt[0]  = pic->field_poc[0];
  430.             rf->field_order_cnt[1]  = pic->field_poc[1];
  431.             rf->frame_idx           = pic_frame_idx;
  432.  
  433.             ++rf;
  434.         }
  435.     }
  436.  
  437.     for (; rf < &render->info.h264.referenceFrames[H264_RF_COUNT]; ++rf) {
  438.         rf->surface             = VDP_INVALID_HANDLE;
  439.         rf->is_long_term        = 0;
  440.         rf->top_is_reference    = 0;
  441.         rf->bottom_is_reference = 0;
  442.         rf->field_order_cnt[0]  = 0;
  443.         rf->field_order_cnt[1]  = 0;
  444.         rf->frame_idx           = 0;
  445.     }
  446. }
  447.  
  448. void ff_vdpau_h264_picture_start(H264Context *h)
  449. {
  450.     struct vdpau_render_state *render;
  451.     int i;
  452.  
  453.     render = (struct vdpau_render_state *)h->cur_pic_ptr->f->data[0];
  454.     assert(render);
  455.  
  456.     for (i = 0; i < 2; ++i) {
  457.         int foc = h->cur_pic_ptr->field_poc[i];
  458.         if (foc == INT_MAX)
  459.             foc = 0;
  460.         render->info.h264.field_order_cnt[i] = foc;
  461.     }
  462.  
  463.     render->info.h264.frame_num = h->frame_num;
  464. }
  465.  
  466. void ff_vdpau_h264_picture_complete(H264Context *h)
  467. {
  468.     struct vdpau_render_state *render;
  469.  
  470.     render = (struct vdpau_render_state *)h->cur_pic_ptr->f->data[0];
  471.     assert(render);
  472.  
  473.     render->info.h264.slice_count = h->current_slice;
  474.     if (render->info.h264.slice_count < 1)
  475.         return;
  476.  
  477.     render->info.h264.is_reference                           = (h->cur_pic_ptr->reference & 3) ? VDP_TRUE : VDP_FALSE;
  478.     render->info.h264.field_pic_flag                         = h->picture_structure != PICT_FRAME;
  479.     render->info.h264.bottom_field_flag                      = h->picture_structure == PICT_BOTTOM_FIELD;
  480.     render->info.h264.num_ref_frames                         = h->sps.ref_frame_count;
  481.     render->info.h264.mb_adaptive_frame_field_flag           = h->sps.mb_aff && !render->info.h264.field_pic_flag;
  482.     render->info.h264.constrained_intra_pred_flag            = h->pps.constrained_intra_pred;
  483.     render->info.h264.weighted_pred_flag                     = h->pps.weighted_pred;
  484.     render->info.h264.weighted_bipred_idc                    = h->pps.weighted_bipred_idc;
  485.     render->info.h264.frame_mbs_only_flag                    = h->sps.frame_mbs_only_flag;
  486.     render->info.h264.transform_8x8_mode_flag                = h->pps.transform_8x8_mode;
  487.     render->info.h264.chroma_qp_index_offset                 = h->pps.chroma_qp_index_offset[0];
  488.     render->info.h264.second_chroma_qp_index_offset          = h->pps.chroma_qp_index_offset[1];
  489.     render->info.h264.pic_init_qp_minus26                    = h->pps.init_qp - 26;
  490.     render->info.h264.num_ref_idx_l0_active_minus1           = h->pps.ref_count[0] - 1;
  491.     render->info.h264.num_ref_idx_l1_active_minus1           = h->pps.ref_count[1] - 1;
  492.     render->info.h264.log2_max_frame_num_minus4              = h->sps.log2_max_frame_num - 4;
  493.     render->info.h264.pic_order_cnt_type                     = h->sps.poc_type;
  494.     render->info.h264.log2_max_pic_order_cnt_lsb_minus4      = h->sps.poc_type ? 0 : h->sps.log2_max_poc_lsb - 4;
  495.     render->info.h264.delta_pic_order_always_zero_flag       = h->sps.delta_pic_order_always_zero_flag;
  496.     render->info.h264.direct_8x8_inference_flag              = h->sps.direct_8x8_inference_flag;
  497.     render->info.h264.entropy_coding_mode_flag               = h->pps.cabac;
  498.     render->info.h264.pic_order_present_flag                 = h->pps.pic_order_present;
  499.     render->info.h264.deblocking_filter_control_present_flag = h->pps.deblocking_filter_parameters_present;
  500.     render->info.h264.redundant_pic_cnt_present_flag         = h->pps.redundant_pic_cnt_present;
  501.     memcpy(render->info.h264.scaling_lists_4x4, h->pps.scaling_matrix4, sizeof(render->info.h264.scaling_lists_4x4));
  502.     memcpy(render->info.h264.scaling_lists_8x8[0], h->pps.scaling_matrix8[0], sizeof(render->info.h264.scaling_lists_8x8[0]));
  503.     memcpy(render->info.h264.scaling_lists_8x8[1], h->pps.scaling_matrix8[3], sizeof(render->info.h264.scaling_lists_8x8[0]));
  504.  
  505.     ff_h264_draw_horiz_band(h, &h->slice_ctx[0], 0, h->avctx->height);
  506.     render->bitstream_buffers_used = 0;
  507. }
  508. #endif /* CONFIG_H264_VDPAU_DECODER */
  509.  
  510. #if CONFIG_MPEG_VDPAU_DECODER || CONFIG_MPEG1_VDPAU_DECODER
  511. void ff_vdpau_mpeg_picture_complete(MpegEncContext *s, const uint8_t *buf,
  512.                                     int buf_size, int slice_count)
  513. {
  514.     struct vdpau_render_state *render, *last, *next;
  515.     int i;
  516.  
  517.     if (!s->current_picture_ptr) return;
  518.  
  519.     render = (struct vdpau_render_state *)s->current_picture_ptr->f->data[0];
  520.     assert(render);
  521.  
  522.     /* fill VdpPictureInfoMPEG1Or2 struct */
  523.     render->info.mpeg.picture_structure          = s->picture_structure;
  524.     render->info.mpeg.picture_coding_type        = s->pict_type;
  525.     render->info.mpeg.intra_dc_precision         = s->intra_dc_precision;
  526.     render->info.mpeg.frame_pred_frame_dct       = s->frame_pred_frame_dct;
  527.     render->info.mpeg.concealment_motion_vectors = s->concealment_motion_vectors;
  528.     render->info.mpeg.intra_vlc_format           = s->intra_vlc_format;
  529.     render->info.mpeg.alternate_scan             = s->alternate_scan;
  530.     render->info.mpeg.q_scale_type               = s->q_scale_type;
  531.     render->info.mpeg.top_field_first            = s->top_field_first;
  532.     render->info.mpeg.full_pel_forward_vector    = s->full_pel[0]; // MPEG-1 only.  Set 0 for MPEG-2
  533.     render->info.mpeg.full_pel_backward_vector   = s->full_pel[1]; // MPEG-1 only.  Set 0 for MPEG-2
  534.     render->info.mpeg.f_code[0][0]               = s->mpeg_f_code[0][0]; // For MPEG-1 fill both horiz. & vert.
  535.     render->info.mpeg.f_code[0][1]               = s->mpeg_f_code[0][1];
  536.     render->info.mpeg.f_code[1][0]               = s->mpeg_f_code[1][0];
  537.     render->info.mpeg.f_code[1][1]               = s->mpeg_f_code[1][1];
  538.     for (i = 0; i < 64; ++i) {
  539.         render->info.mpeg.intra_quantizer_matrix[i]     = s->intra_matrix[i];
  540.         render->info.mpeg.non_intra_quantizer_matrix[i] = s->inter_matrix[i];
  541.     }
  542.  
  543.     render->info.mpeg.forward_reference          = VDP_INVALID_HANDLE;
  544.     render->info.mpeg.backward_reference         = VDP_INVALID_HANDLE;
  545.  
  546.     switch(s->pict_type){
  547.     case  AV_PICTURE_TYPE_B:
  548.         next = (struct vdpau_render_state *)s->next_picture.f->data[0];
  549.         assert(next);
  550.         render->info.mpeg.backward_reference     = next->surface;
  551.         // no return here, going to set forward prediction
  552.     case  AV_PICTURE_TYPE_P:
  553.         last = (struct vdpau_render_state *)s->last_picture.f->data[0];
  554.         if (!last) // FIXME: Does this test make sense?
  555.             last = render; // predict second field from the first
  556.         render->info.mpeg.forward_reference      = last->surface;
  557.     }
  558.  
  559.     ff_vdpau_add_data_chunk(s->current_picture_ptr->f->data[0], buf, buf_size);
  560.  
  561.     render->info.mpeg.slice_count                = slice_count;
  562.  
  563.     if (slice_count)
  564.         ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);
  565.     render->bitstream_buffers_used               = 0;
  566. }
  567. #endif /* CONFIG_MPEG_VDPAU_DECODER || CONFIG_MPEG1_VDPAU_DECODER */
  568.  
  569. #if CONFIG_VC1_VDPAU_DECODER
  570. void ff_vdpau_vc1_decode_picture(MpegEncContext *s, const uint8_t *buf,
  571.                                  int buf_size)
  572. {
  573.     VC1Context *v = s->avctx->priv_data;
  574.     struct vdpau_render_state *render, *last, *next;
  575.  
  576.     render = (struct vdpau_render_state *)s->current_picture.f->data[0];
  577.     assert(render);
  578.  
  579.     /*  fill LvPictureInfoVC1 struct */
  580.     render->info.vc1.frame_coding_mode  = v->fcm ? v->fcm + 1 : 0;
  581.     render->info.vc1.postprocflag       = v->postprocflag;
  582.     render->info.vc1.pulldown           = v->broadcast;
  583.     render->info.vc1.interlace          = v->interlace;
  584.     render->info.vc1.tfcntrflag         = v->tfcntrflag;
  585.     render->info.vc1.finterpflag        = v->finterpflag;
  586.     render->info.vc1.psf                = v->psf;
  587.     render->info.vc1.dquant             = v->dquant;
  588.     render->info.vc1.panscan_flag       = v->panscanflag;
  589.     render->info.vc1.refdist_flag       = v->refdist_flag;
  590.     render->info.vc1.quantizer          = v->quantizer_mode;
  591.     render->info.vc1.extended_mv        = v->extended_mv;
  592.     render->info.vc1.extended_dmv       = v->extended_dmv;
  593.     render->info.vc1.overlap            = v->overlap;
  594.     render->info.vc1.vstransform        = v->vstransform;
  595.     render->info.vc1.loopfilter         = v->s.loop_filter;
  596.     render->info.vc1.fastuvmc           = v->fastuvmc;
  597.     render->info.vc1.range_mapy_flag    = v->range_mapy_flag;
  598.     render->info.vc1.range_mapy         = v->range_mapy;
  599.     render->info.vc1.range_mapuv_flag   = v->range_mapuv_flag;
  600.     render->info.vc1.range_mapuv        = v->range_mapuv;
  601.     /* Specific to simple/main profile only */
  602.     render->info.vc1.multires           = v->multires;
  603.     render->info.vc1.syncmarker         = v->resync_marker;
  604.     render->info.vc1.rangered           = v->rangered | (v->rangeredfrm << 1);
  605.     render->info.vc1.maxbframes         = v->s.max_b_frames;
  606.  
  607.     render->info.vc1.deblockEnable      = v->postprocflag & 1;
  608.     render->info.vc1.pquant             = v->pq;
  609.  
  610.     render->info.vc1.forward_reference  = VDP_INVALID_HANDLE;
  611.     render->info.vc1.backward_reference = VDP_INVALID_HANDLE;
  612.  
  613.     if (v->bi_type)
  614.         render->info.vc1.picture_type = 4;
  615.     else
  616.         render->info.vc1.picture_type = s->pict_type - 1 + s->pict_type / 3;
  617.  
  618.     switch(s->pict_type){
  619.     case  AV_PICTURE_TYPE_B:
  620.         next = (struct vdpau_render_state *)s->next_picture.f->data[0];
  621.         assert(next);
  622.         render->info.vc1.backward_reference = next->surface;
  623.         // no break here, going to set forward prediction
  624.     case  AV_PICTURE_TYPE_P:
  625.         last = (struct vdpau_render_state *)s->last_picture.f->data[0];
  626.         if (!last) // FIXME: Does this test make sense?
  627.             last = render; // predict second field from the first
  628.         render->info.vc1.forward_reference = last->surface;
  629.     }
  630.  
  631.     ff_vdpau_add_data_chunk(s->current_picture_ptr->f->data[0], buf, buf_size);
  632.  
  633.     render->info.vc1.slice_count          = 1;
  634.  
  635.     ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);
  636.     render->bitstream_buffers_used        = 0;
  637. }
  638. #endif /* (CONFIG_VC1_VDPAU_DECODER */
  639.  
  640. #if CONFIG_MPEG4_VDPAU_DECODER
  641. void ff_vdpau_mpeg4_decode_picture(Mpeg4DecContext *ctx, const uint8_t *buf,
  642.                                    int buf_size)
  643. {
  644.     MpegEncContext *s = &ctx->m;
  645.     struct vdpau_render_state *render, *last, *next;
  646.     int i;
  647.  
  648.     if (!s->current_picture_ptr) return;
  649.  
  650.     render = (struct vdpau_render_state *)s->current_picture_ptr->f->data[0];
  651.     assert(render);
  652.  
  653.     /* fill VdpPictureInfoMPEG4Part2 struct */
  654.     render->info.mpeg4.trd[0]                            = s->pp_time;
  655.     render->info.mpeg4.trb[0]                            = s->pb_time;
  656.     render->info.mpeg4.trd[1]                            = s->pp_field_time >> 1;
  657.     render->info.mpeg4.trb[1]                            = s->pb_field_time >> 1;
  658.     render->info.mpeg4.vop_time_increment_resolution     = s->avctx->time_base.den;
  659.     render->info.mpeg4.vop_coding_type                   = 0;
  660.     render->info.mpeg4.vop_fcode_forward                 = s->f_code;
  661.     render->info.mpeg4.vop_fcode_backward                = s->b_code;
  662.     render->info.mpeg4.resync_marker_disable             = !ctx->resync_marker;
  663.     render->info.mpeg4.interlaced                        = !s->progressive_sequence;
  664.     render->info.mpeg4.quant_type                        = s->mpeg_quant;
  665.     render->info.mpeg4.quarter_sample                    = s->quarter_sample;
  666.     render->info.mpeg4.short_video_header                = s->avctx->codec->id == AV_CODEC_ID_H263;
  667.     render->info.mpeg4.rounding_control                  = s->no_rounding;
  668.     render->info.mpeg4.alternate_vertical_scan_flag      = s->alternate_scan;
  669.     render->info.mpeg4.top_field_first                   = s->top_field_first;
  670.     for (i = 0; i < 64; ++i) {
  671.         render->info.mpeg4.intra_quantizer_matrix[i]     = s->intra_matrix[i];
  672.         render->info.mpeg4.non_intra_quantizer_matrix[i] = s->inter_matrix[i];
  673.     }
  674.     render->info.mpeg4.forward_reference                 = VDP_INVALID_HANDLE;
  675.     render->info.mpeg4.backward_reference                = VDP_INVALID_HANDLE;
  676.  
  677.     switch (s->pict_type) {
  678.     case AV_PICTURE_TYPE_B:
  679.         next = (struct vdpau_render_state *)s->next_picture.f->data[0];
  680.         assert(next);
  681.         render->info.mpeg4.backward_reference     = next->surface;
  682.         render->info.mpeg4.vop_coding_type        = 2;
  683.         // no break here, going to set forward prediction
  684.     case AV_PICTURE_TYPE_P:
  685.         last = (struct vdpau_render_state *)s->last_picture.f->data[0];
  686.         assert(last);
  687.         render->info.mpeg4.forward_reference      = last->surface;
  688.     }
  689.  
  690.     ff_vdpau_add_data_chunk(s->current_picture_ptr->f->data[0], buf, buf_size);
  691.  
  692.     ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);
  693.     render->bitstream_buffers_used = 0;
  694. }
  695. #endif /* CONFIG_MPEG4_VDPAU_DECODER */
  696. #endif /* FF_API_VDPAU */
  697.  
  698. int av_vdpau_get_profile(AVCodecContext *avctx, VdpDecoderProfile *profile)
  699. {
  700. #define PROFILE(prof)                      \
  701. do {                                       \
  702.     *profile = VDP_DECODER_PROFILE_##prof; \
  703.     return 0;                              \
  704. } while (0)
  705.  
  706.     switch (avctx->codec_id) {
  707.     case AV_CODEC_ID_MPEG1VIDEO:               PROFILE(MPEG1);
  708.     case AV_CODEC_ID_MPEG2VIDEO:
  709.         switch (avctx->profile) {
  710.         case FF_PROFILE_MPEG2_MAIN:            PROFILE(MPEG2_MAIN);
  711.         case FF_PROFILE_MPEG2_SIMPLE:          PROFILE(MPEG2_SIMPLE);
  712.         default:                               return AVERROR(EINVAL);
  713.         }
  714.     case AV_CODEC_ID_H263:                     PROFILE(MPEG4_PART2_ASP);
  715.     case AV_CODEC_ID_MPEG4:
  716.         switch (avctx->profile) {
  717.         case FF_PROFILE_MPEG4_SIMPLE:          PROFILE(MPEG4_PART2_SP);
  718.         case FF_PROFILE_MPEG4_ADVANCED_SIMPLE: PROFILE(MPEG4_PART2_ASP);
  719.         default:                               return AVERROR(EINVAL);
  720.         }
  721.     case AV_CODEC_ID_H264:
  722.         switch (avctx->profile & ~FF_PROFILE_H264_INTRA) {
  723.         case FF_PROFILE_H264_BASELINE:         PROFILE(H264_BASELINE);
  724.         case FF_PROFILE_H264_CONSTRAINED_BASELINE:
  725.         case FF_PROFILE_H264_MAIN:             PROFILE(H264_MAIN);
  726.         case FF_PROFILE_H264_HIGH:             PROFILE(H264_HIGH);
  727. #ifdef VDP_DECODER_PROFILE_H264_EXTENDED
  728.         case FF_PROFILE_H264_EXTENDED:         PROFILE(H264_EXTENDED);
  729. #endif
  730.         default:                               return AVERROR(EINVAL);
  731.         }
  732.     case AV_CODEC_ID_WMV3:
  733.     case AV_CODEC_ID_VC1:
  734.         switch (avctx->profile) {
  735.         case FF_PROFILE_VC1_SIMPLE:            PROFILE(VC1_SIMPLE);
  736.         case FF_PROFILE_VC1_MAIN:              PROFILE(VC1_MAIN);
  737.         case FF_PROFILE_VC1_ADVANCED:          PROFILE(VC1_ADVANCED);
  738.         default:                               return AVERROR(EINVAL);
  739.         }
  740.     }
  741.     return AVERROR(EINVAL);
  742. #undef PROFILE
  743. }
  744.  
  745. AVVDPAUContext *av_vdpau_alloc_context(void)
  746. {
  747.     return av_mallocz(sizeof(AVVDPAUContext));
  748. }
  749.  
  750. int av_vdpau_bind_context(AVCodecContext *avctx, VdpDevice device,
  751.                           VdpGetProcAddress *get_proc, unsigned flags)
  752. {
  753.     VDPAUHWContext *hwctx;
  754.  
  755.     if (flags & ~(AV_HWACCEL_FLAG_IGNORE_LEVEL|AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH))
  756.         return AVERROR(EINVAL);
  757.  
  758.     if (av_reallocp(&avctx->hwaccel_context, sizeof(*hwctx)))
  759.         return AVERROR(ENOMEM);
  760.  
  761.     hwctx = avctx->hwaccel_context;
  762.  
  763.     memset(hwctx, 0, sizeof(*hwctx));
  764.     hwctx->context.decoder  = VDP_INVALID_HANDLE;
  765.     hwctx->device           = device;
  766.     hwctx->get_proc_address = get_proc;
  767.     hwctx->flags            = flags;
  768.     hwctx->reset            = 1;
  769.     return 0;
  770. }
  771.  
  772. /* @}*/
  773.