Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright 2011 Maarten Lankhorst
  3.  *
  4.  * Permission is hereby granted, free of charge, to any person obtaining a
  5.  * copy of this software and associated documentation files (the "Software"),
  6.  * to deal in the Software without restriction, including without limitation
  7.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8.  * and/or sell copies of the Software, and to permit persons to whom the
  9.  * Software is 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
  18.  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19.  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20.  * OTHER DEALINGS IN THE SOFTWARE.
  21.  */
  22.  
  23. #include "vl/vl_decoder.h"
  24. #include "vl/vl_video_buffer.h"
  25.  
  26. #include "nouveau_screen.h"
  27. #include "nouveau_context.h"
  28. #include "nouveau_video.h"
  29.  
  30. #include "nouveau/nouveau_buffer.h"
  31. #include "util/u_video.h"
  32. #include "util/u_format.h"
  33. #include "util/u_sampler.h"
  34.  
  35. static int
  36. nouveau_vpe_init(struct nouveau_decoder *dec) {
  37.    int ret;
  38.    if (dec->cmds)
  39.       return 0;
  40.    ret = nouveau_bo_map(dec->cmd_bo, NOUVEAU_BO_RDWR, dec->client);
  41.    if (ret) {
  42.       debug_printf("Mapping cmd bo: %s\n", strerror(-ret));
  43.       return ret;
  44.    }
  45.    ret = nouveau_bo_map(dec->data_bo, NOUVEAU_BO_RDWR, dec->client);
  46.    if (ret) {
  47.       debug_printf("Mapping data bo: %s\n", strerror(-ret));
  48.       return ret;
  49.    }
  50.    dec->cmds = dec->cmd_bo->map;
  51.    dec->data = dec->data_bo->map;
  52.    return ret;
  53. }
  54.  
  55. static void
  56. nouveau_vpe_synch(struct nouveau_decoder *dec) {
  57.    struct nouveau_pushbuf *push = dec->push;
  58. #if 0
  59.    if (dec->fence_map) {
  60.       BEGIN_NV04(push, NV84_MPEG(QUERY_COUNTER), 1);
  61.       PUSH_DATA (push, ++dec->fence_seq);
  62.       PUSH_KICK (push);
  63.       while (dec->fence_map[0] != dec->fence_seq)
  64.          usleep(1000);
  65.    } else
  66. #endif
  67.       PUSH_KICK(push);
  68. }
  69.  
  70. static void
  71. nouveau_vpe_fini(struct nouveau_decoder *dec) {
  72.    struct nouveau_pushbuf *push = dec->push;
  73.    if (!dec->cmds)
  74.       return;
  75.  
  76.    nouveau_pushbuf_space(push, 8, 2, 0);
  77.    nouveau_bufctx_reset(dec->bufctx, NV31_VIDEO_BIND_CMD);
  78.  
  79. #define BCTX_ARGS dec->bufctx, NV31_VIDEO_BIND_CMD, NOUVEAU_BO_RD
  80.  
  81.    BEGIN_NV04(push, NV31_MPEG(CMD_OFFSET), 2);
  82.    PUSH_MTHDl(push, NV31_MPEG(CMD_OFFSET), dec->cmd_bo, 0, BCTX_ARGS);
  83.    PUSH_DATA (push, dec->ofs * 4);
  84.  
  85.    BEGIN_NV04(push, NV31_MPEG(DATA_OFFSET), 2);
  86.    PUSH_MTHDl(push, NV31_MPEG(DATA_OFFSET), dec->data_bo, 0, BCTX_ARGS);
  87.    PUSH_DATA (push, dec->data_pos * 4);
  88.  
  89. #undef BCTX_ARGS
  90.  
  91.    if (unlikely(nouveau_pushbuf_validate(dec->push)))
  92.       return;
  93.  
  94.    BEGIN_NV04(push, NV31_MPEG(EXEC), 1);
  95.    PUSH_DATA (push, 1);
  96.  
  97.    nouveau_vpe_synch(dec);
  98.    dec->ofs = dec->data_pos = dec->num_surfaces = 0;
  99.    dec->cmds = dec->data = NULL;
  100.    dec->current = dec->future = dec->past = 8;
  101. }
  102.  
  103. static INLINE void
  104. nouveau_vpe_mb_dct_blocks(struct nouveau_decoder *dec, const struct pipe_mpeg12_macroblock *mb)
  105. {
  106.    int cbb;
  107.    unsigned cbp = mb->coded_block_pattern;
  108.    short *db = mb->blocks;
  109.    for (cbb = 0x20; cbb > 0; cbb >>= 1) {
  110.       if (cbb & cbp) {
  111.          static const int lookup[64] = {
  112.              0, 1, 8,16, 9, 2, 3,10,
  113.             17,24,32,25,18,11, 4, 5,
  114.             12,19,26,33,40,48,41,34,
  115.             27,20,13, 6, 7,14,21,28,
  116.             35,42,49,56,57,50,43,36,
  117.             29,22,15,23,30,37,44,51,
  118.             58,59,52,45,38,31,39,46,
  119.             53,60,61,54,47,55,62,63
  120.          };
  121.          int i, j = 0, found = 0;
  122.          for (i = 0; i < 64; ++i) {
  123.             if (!db[lookup[i]]) { j += 2; continue; }
  124.             dec->data[dec->data_pos++] = (db[lookup[i]] << 16) | j;
  125.             j = 0;
  126.             found = 1;
  127.          }
  128.          if (found)
  129.             dec->data[dec->data_pos - 1] |= 1;
  130.          else
  131.             dec->data[dec->data_pos++] = 1;
  132.          db += 64;
  133.       } else if (mb->macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA) {
  134.          dec->data[dec->data_pos++] = 1;
  135.       }
  136.    }
  137. }
  138.  
  139. static INLINE void
  140. nouveau_vpe_mb_data_blocks(struct nouveau_decoder *dec, const struct pipe_mpeg12_macroblock *mb)
  141. {
  142.    int cbb;
  143.    unsigned cbp = mb->coded_block_pattern;
  144.    short *db = mb->blocks;
  145.    for (cbb = 0x20; cbb > 0; cbb >>= 1) {
  146.       if (cbb & cbp) {
  147.          memcpy(&dec->data[dec->data_pos], db, 128);
  148.          dec->data_pos += 32;
  149.          db += 64;
  150.       } else if (mb->macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA) {
  151.          memset(&dec->data[dec->data_pos], 0, 128);
  152.          dec->data_pos += 32;
  153.       }
  154.    }
  155. }
  156.  
  157. static INLINE void
  158. nouveau_vpe_mb_dct_header(struct nouveau_decoder *dec,
  159.                           const struct pipe_mpeg12_macroblock *mb,
  160.                           bool luma)
  161. {
  162.    unsigned base_dct, cbp;
  163.    bool intra = mb->macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA;
  164.    unsigned x = mb->x * 16;
  165.    unsigned y = luma ? mb->y * 16 : mb->y * 8;
  166.  
  167.    /* Setup the base dct header */
  168.    base_dct = dec->current << NV17_MPEG_CMD_CHROMA_MB_HEADER_SURFACE__SHIFT;
  169.    base_dct |= NV17_MPEG_CMD_CHROMA_MB_HEADER_RUN_SINGLE;
  170.  
  171.    if (!(mb->x & 1))
  172.       base_dct |= NV17_MPEG_CMD_CHROMA_MB_HEADER_X_COORD_EVEN;
  173.    if (intra)
  174.       cbp = 0x3f;
  175.    else
  176.       cbp = mb->coded_block_pattern;
  177.  
  178.    if (dec->picture_structure == PIPE_MPEG12_PICTURE_STRUCTURE_FRAME) {
  179.       base_dct |= NV17_MPEG_CMD_CHROMA_MB_HEADER_TYPE_FRAME;
  180.       if (luma && mb->macroblock_modes.bits.dct_type == PIPE_MPEG12_DCT_TYPE_FIELD)
  181.          base_dct |= NV17_MPEG_CMD_CHROMA_MB_HEADER_FRAME_DCT_TYPE_FIELD;
  182.    } else {
  183.       if (dec->picture_structure == PIPE_MPEG12_PICTURE_STRUCTURE_FIELD_BOTTOM)
  184.          base_dct |= NV17_MPEG_CMD_CHROMA_MB_HEADER_FIELD_BOTTOM;
  185.       if (!intra)
  186.          y *= 2;
  187.    }
  188.  
  189.    if (luma) {
  190.       base_dct |= NV17_MPEG_CMD_LUMA_MB_HEADER_OP_LUMA_MB_HEADER;
  191.       base_dct |= (cbp >> 2) << NV17_MPEG_CMD_LUMA_MB_HEADER_CBP__SHIFT;
  192.    } else {
  193.       base_dct |= NV17_MPEG_CMD_CHROMA_MB_HEADER_OP_CHROMA_MB_HEADER;
  194.       base_dct |= (cbp & 3) << NV17_MPEG_CMD_CHROMA_MB_HEADER_CBP__SHIFT;
  195.    }
  196.    nouveau_vpe_write(dec, base_dct);
  197.    nouveau_vpe_write(dec, NV17_MPEG_CMD_MB_COORDS_OP_MB_COORDS |
  198.                      x | (y << NV17_MPEG_CMD_MB_COORDS_Y__SHIFT));
  199. }
  200.  
  201. static INLINE unsigned int
  202. nouveau_vpe_mb_mv_flags(bool luma, int mv_h, int mv_v, bool forward, bool first, bool vert)
  203. {
  204.    unsigned mc_header = 0;
  205.    if (luma)
  206.       mc_header |= NV17_MPEG_CMD_LUMA_MV_HEADER_OP_LUMA_MV_HEADER;
  207.    else
  208.       mc_header |= NV17_MPEG_CMD_CHROMA_MV_HEADER_OP_CHROMA_MV_HEADER;
  209.    if (mv_h & 1)
  210.       mc_header |= NV17_MPEG_CMD_CHROMA_MV_HEADER_X_HALF;
  211.    if (mv_v & 1)
  212.       mc_header |= NV17_MPEG_CMD_CHROMA_MV_HEADER_Y_HALF;
  213.    if (!forward)
  214.       mc_header |= NV17_MPEG_CMD_CHROMA_MV_HEADER_DIRECTION_BACKWARD;
  215.    if (!first)
  216.       mc_header |= NV17_MPEG_CMD_CHROMA_MV_HEADER_IDX;
  217.    if (vert)
  218.       mc_header |= NV17_MPEG_CMD_LUMA_MV_HEADER_FIELD_BOTTOM;
  219.    return mc_header;
  220. }
  221.  
  222. static unsigned pos(int pos, int mov, int max) {
  223.    int ret = pos + mov;
  224.    if (pos < 0)
  225.       return 0;
  226.    if (pos >= max)
  227.       return max-1;
  228.    return ret;
  229. }
  230.  
  231. /* because we want -1 / 2 = -1 */
  232. static int div_down(int val, int mult) {
  233.    val &= ~(mult - 1);
  234.    return val / mult;
  235. }
  236.  
  237. static int div_up(int val, int mult) {
  238.    val += mult - 1;
  239.    return val / mult;
  240. }
  241.  
  242. static INLINE void
  243. nouveau_vpe_mb_mv(struct nouveau_decoder *dec, unsigned mc_header,
  244.                    bool luma, bool frame, bool forward, bool vert,
  245.                    int x, int y, const short motions[2],
  246.                    unsigned surface, bool first)
  247. {
  248.    unsigned mc_vector;
  249.    int mv_horizontal = motions[0];
  250.    int mv_vertical = motions[1];
  251.    int mv2 = mc_header & NV17_MPEG_CMD_CHROMA_MV_HEADER_COUNT_2;
  252.    unsigned width = dec->base.width;
  253.    unsigned height = dec->base.height;
  254.    if (mv2)
  255.       mv_vertical = div_down(mv_vertical, 2);
  256.    assert(frame); // Untested for non-frames
  257.    if (!frame)
  258.       height *= 2;
  259.  
  260.    mc_header |= surface << NV17_MPEG_CMD_CHROMA_MV_HEADER_SURFACE__SHIFT;
  261.    if (!luma) {
  262.       mv_vertical = div_up(mv_vertical, 2);
  263.       mv_horizontal = div_up(mv_horizontal, 2);
  264.       height /= 2;
  265.    }
  266.    mc_header |= nouveau_vpe_mb_mv_flags(luma, mv_horizontal, mv_vertical, forward, first, vert);
  267.    nouveau_vpe_write(dec, mc_header);
  268.  
  269.    mc_vector = NV17_MPEG_CMD_MV_COORDS_OP_MV_COORDS;
  270.    if (luma)
  271.       mc_vector |= pos(x, div_down(mv_horizontal, 2), width);
  272.    else
  273.       mc_vector |= pos(x, mv_horizontal & ~1, width);
  274.    if (!mv2)
  275.       mc_vector |= pos(y, div_down(mv_vertical, 2), height) << NV17_MPEG_CMD_MV_COORDS_Y__SHIFT;
  276.    else
  277.       mc_vector |= pos(y, mv_vertical & ~1, height) << NV17_MPEG_CMD_MV_COORDS_Y__SHIFT;
  278.    nouveau_vpe_write(dec, mc_vector);
  279. }
  280.  
  281. static void
  282. nouveau_vpe_mb_mv_header(struct nouveau_decoder *dec,
  283.                          const struct pipe_mpeg12_macroblock *mb,
  284.                          bool luma)
  285. {
  286.    bool frame = dec->picture_structure == PIPE_MPEG12_PICTURE_STRUCTURE_FRAME;
  287.    unsigned base;
  288.    bool forward, backward;
  289.    int y, y2, x = mb->x * 16;
  290.    if (luma)
  291.       y = mb->y * (frame ? 16 : 32);
  292.    else
  293.       y = mb->y * (frame ? 8 : 16);
  294.    if (frame)
  295.       y2 = y;
  296.    else
  297.       y2 = y + (luma ? 16 : 8);
  298.  
  299.    forward = mb->macroblock_type & PIPE_MPEG12_MB_TYPE_MOTION_FORWARD;
  300.    backward = mb->macroblock_type & PIPE_MPEG12_MB_TYPE_MOTION_BACKWARD;
  301.    assert(!forward || dec->past < 8);
  302.    assert(!backward || dec->future < 8);
  303.    if (frame) {
  304.       switch (mb->macroblock_modes.bits.frame_motion_type) {
  305.       case PIPE_MPEG12_MO_TYPE_FRAME: goto mv1;
  306.       case PIPE_MPEG12_MO_TYPE_FIELD: goto mv2;
  307.       case PIPE_MPEG12_MO_TYPE_DUAL_PRIME: {
  308.          base = NV17_MPEG_CMD_CHROMA_MV_HEADER_COUNT_2;
  309.          if (forward) {
  310.             nouveau_vpe_mb_mv(dec, base, luma, frame, TRUE, FALSE,
  311.                               x, y, mb->PMV[0][0], dec->past, TRUE);
  312.             nouveau_vpe_mb_mv(dec, base, luma, frame, TRUE, TRUE,
  313.                               x, y2, mb->PMV[0][0], dec->past, FALSE);
  314.          }
  315.          if (backward && forward) {
  316.             nouveau_vpe_mb_mv(dec, base, luma, frame, !forward, TRUE,
  317.                               x, y, mb->PMV[1][0], dec->future, TRUE);
  318.             nouveau_vpe_mb_mv(dec, base, luma, frame, !forward, FALSE,
  319.                               x, y2, mb->PMV[1][1], dec->future, FALSE);
  320.          } else assert(!backward);
  321.          break;
  322.       }
  323.       default: assert(0);
  324.       }
  325.    } else {
  326.       switch (mb->macroblock_modes.bits.field_motion_type) {
  327.       case PIPE_MPEG12_MO_TYPE_FIELD: goto mv1;
  328.       case PIPE_MPEG12_MO_TYPE_16x8: goto mv2;
  329.       case PIPE_MPEG12_MO_TYPE_DUAL_PRIME: {
  330.       base = NV17_MPEG_CMD_CHROMA_MV_HEADER_MV_SPLIT_HALF_MB;
  331.          if (frame)
  332.             base |= NV17_MPEG_CMD_CHROMA_MV_HEADER_TYPE_FRAME;
  333.          if (forward)
  334.             nouveau_vpe_mb_mv(dec, base, luma, frame, TRUE,
  335.                               dec->picture_structure != PIPE_MPEG12_PICTURE_STRUCTURE_FIELD_TOP,
  336.                               x, y, mb->PMV[0][0], dec->past, TRUE);
  337.          if (backward && forward)
  338.             nouveau_vpe_mb_mv(dec, base, luma, frame, FALSE,
  339.                               dec->picture_structure == PIPE_MPEG12_PICTURE_STRUCTURE_FIELD_TOP,
  340.                               x, y, mb->PMV[0][1], dec->future, TRUE);
  341.          else assert(!backward);
  342.          break;
  343.       }
  344.       default: assert(0);
  345.       }
  346.    }
  347.    return;
  348.  
  349. mv1:
  350.    base = NV17_MPEG_CMD_CHROMA_MV_HEADER_MV_SPLIT_HALF_MB;
  351.    if (frame)
  352.        base |= NV17_MPEG_CMD_CHROMA_MV_HEADER_TYPE_FRAME;
  353.     /* frame 16x16 */
  354.    if (forward)
  355.        nouveau_vpe_mb_mv(dec, base, luma, frame, TRUE, FALSE,
  356.                          x, y, mb->PMV[0][0], dec->past, TRUE);
  357.    if (backward)
  358.        nouveau_vpe_mb_mv(dec, base, luma, frame, !forward, FALSE,
  359.                          x, y, mb->PMV[0][1], dec->future, TRUE);
  360.     return;
  361.  
  362. mv2:
  363.    base = NV17_MPEG_CMD_CHROMA_MV_HEADER_COUNT_2;
  364.    if (!frame)
  365.       base |= NV17_MPEG_CMD_CHROMA_MV_HEADER_MV_SPLIT_HALF_MB;
  366.    if (forward) {
  367.       nouveau_vpe_mb_mv(dec, base, luma, frame, TRUE,
  368.                         mb->motion_vertical_field_select & PIPE_MPEG12_FS_FIRST_FORWARD,
  369.                         x, y, mb->PMV[0][0], dec->past, TRUE);
  370.       nouveau_vpe_mb_mv(dec, base, luma, frame, TRUE,
  371.                         mb->motion_vertical_field_select & PIPE_MPEG12_FS_SECOND_FORWARD,
  372.                         x, y2, mb->PMV[1][0], dec->past, FALSE);
  373.    }
  374.    if (backward) {
  375.       nouveau_vpe_mb_mv(dec, base, luma, frame, !forward,
  376.                         mb->motion_vertical_field_select & PIPE_MPEG12_FS_FIRST_BACKWARD,
  377.                         x, y, mb->PMV[0][1], dec->future, TRUE);
  378.       nouveau_vpe_mb_mv(dec, base, luma, frame, !forward,
  379.                         mb->motion_vertical_field_select & PIPE_MPEG12_FS_SECOND_BACKWARD,
  380.                         x, y2, mb->PMV[1][1], dec->future, FALSE);
  381.    }
  382. }
  383.  
  384. static unsigned
  385. nouveau_decoder_surface_index(struct nouveau_decoder *dec,
  386.                               struct pipe_video_buffer *buffer)
  387. {
  388.    struct nouveau_video_buffer *buf = (struct nouveau_video_buffer *)buffer;
  389.    struct nouveau_pushbuf *push = dec->push;
  390.    struct nouveau_bo *bo_y = nv04_resource(buf->resources[0])->bo;
  391.    struct nouveau_bo *bo_c = nv04_resource(buf->resources[1])->bo;
  392.  
  393.    unsigned i;
  394.  
  395.    if (!buf)
  396.       return 8;
  397.    for (i = 0; i < dec->num_surfaces; ++i) {
  398.       if (dec->surfaces[i] == buf)
  399.          return i;
  400.    }
  401.    assert(i < 8);
  402.    dec->surfaces[i] = buf;
  403.    dec->num_surfaces++;
  404.  
  405.    nouveau_bufctx_reset(dec->bufctx, NV31_VIDEO_BIND_IMG(i));
  406.  
  407. #define BCTX_ARGS dec->bufctx, NV31_VIDEO_BIND_IMG(i), NOUVEAU_BO_RDWR
  408.    BEGIN_NV04(push, NV31_MPEG(IMAGE_Y_OFFSET(i)), 2);
  409.    PUSH_MTHDl(push, NV31_MPEG(IMAGE_Y_OFFSET(i)), bo_y, 0, BCTX_ARGS);
  410.    PUSH_MTHDl(push, NV31_MPEG(IMAGE_C_OFFSET(i)), bo_c, 0, BCTX_ARGS);
  411. #undef BCTX_ARGS
  412.  
  413.    return i;
  414. }
  415.  
  416. static void
  417. nouveau_decoder_begin_frame(struct pipe_video_decoder *decoder,
  418.                             struct pipe_video_buffer *target,
  419.                             struct pipe_picture_desc *picture)
  420. {
  421. }
  422.  
  423. static void
  424. nouveau_decoder_decode_macroblock(struct pipe_video_decoder *decoder,
  425.                                   struct pipe_video_buffer *target,
  426.                                   struct pipe_picture_desc *picture,
  427.                                   const struct pipe_macroblock *pipe_mb,
  428.                                   unsigned num_macroblocks)
  429. {
  430.    struct nouveau_decoder *dec = (struct nouveau_decoder *)decoder;
  431.    struct pipe_mpeg12_picture_desc *desc = (struct pipe_mpeg12_picture_desc*)picture;
  432.    const struct pipe_mpeg12_macroblock *mb;
  433.    unsigned i;
  434.    assert(target->width == decoder->width);
  435.    assert(target->height == decoder->height);
  436.  
  437.    dec->current = nouveau_decoder_surface_index(dec, target);
  438.    assert(dec->current < 8);
  439.    dec->picture_structure = desc->picture_structure;
  440.    if (desc->ref[1])
  441.       dec->future = nouveau_decoder_surface_index(dec, desc->ref[1]);
  442.    if (desc->ref[0])
  443.       dec->past = nouveau_decoder_surface_index(dec, desc->ref[0]);
  444.  
  445.    if (nouveau_vpe_init(dec)) return;
  446.    mb = (const struct pipe_mpeg12_macroblock *)pipe_mb;
  447.    for (i = 0; i < num_macroblocks; ++i, mb++) {
  448.       if (mb->macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA) {
  449.          nouveau_vpe_mb_dct_header(dec, mb, TRUE);
  450.          nouveau_vpe_mb_dct_header(dec, mb, FALSE);
  451.       } else {
  452.          nouveau_vpe_mb_mv_header(dec, mb, TRUE);
  453.          nouveau_vpe_mb_dct_header(dec, mb, TRUE);
  454.  
  455.          nouveau_vpe_mb_mv_header(dec, mb, FALSE);
  456.          nouveau_vpe_mb_dct_header(dec, mb, FALSE);
  457.       }
  458.       if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT)
  459.          nouveau_vpe_mb_dct_blocks(dec, mb);
  460.       else
  461.          nouveau_vpe_mb_data_blocks(dec, mb);
  462.    }
  463. }
  464.  
  465. static void
  466. nouveau_decoder_end_frame(struct pipe_video_decoder *decoder,
  467.                           struct pipe_video_buffer *target,
  468.                           struct pipe_picture_desc *picture)
  469. {
  470. }
  471.  
  472. static void
  473. nouveau_decoder_flush(struct pipe_video_decoder *decoder)
  474. {
  475.    struct nouveau_decoder *dec = (struct nouveau_decoder *)decoder;
  476.    if (dec->ofs)
  477.       nouveau_vpe_fini(dec);
  478. }
  479.  
  480. static void
  481. nouveau_decoder_destroy(struct pipe_video_decoder *decoder)
  482. {
  483.    struct nouveau_decoder *dec = (struct nouveau_decoder*)decoder;
  484.  
  485.    if (dec->data_bo)
  486.       nouveau_bo_ref(NULL, &dec->data_bo);
  487.    if (dec->cmd_bo)
  488.       nouveau_bo_ref(NULL, &dec->cmd_bo);
  489.    if (dec->fence_bo)
  490.       nouveau_bo_ref(NULL, &dec->fence_bo);
  491.  
  492.    nouveau_object_del(&dec->mpeg);
  493.  
  494.    if (dec->bufctx)
  495.       nouveau_bufctx_del(&dec->bufctx);
  496.    if (dec->push)
  497.       nouveau_pushbuf_del(&dec->push);
  498.    if (dec->client)
  499.       nouveau_client_del(&dec->client);
  500.    if (dec->chan)
  501.       nouveau_object_del(&dec->chan);
  502.  
  503.    FREE(dec);
  504. }
  505.  
  506. static struct pipe_video_decoder *
  507. nouveau_create_decoder(struct pipe_context *context,
  508.                        struct nouveau_screen *screen,
  509.                        enum pipe_video_profile profile,
  510.                        enum pipe_video_entrypoint entrypoint,
  511.                        enum pipe_video_chroma_format chroma_format,
  512.                        unsigned width, unsigned height,
  513.                        unsigned max_references, bool expect_chunked_decode)
  514. {
  515.    struct nv04_fifo nv04_data = { .vram = 0xbeef0201, .gart = 0xbeef0202 };
  516.    struct nouveau_object *mpeg = NULL;
  517.    struct nouveau_decoder *dec;
  518.    struct nouveau_pushbuf *push;
  519.    int ret;
  520.    bool is8274 = screen->device->chipset > 0x80;
  521.  
  522.    debug_printf("Acceleration level: %s\n", entrypoint <= PIPE_VIDEO_ENTRYPOINT_BITSTREAM ? "bit":
  523.                                             entrypoint == PIPE_VIDEO_ENTRYPOINT_IDCT ? "IDCT" : "MC");
  524.  
  525.    if (getenv("XVMC_VL"))
  526.       goto vl;
  527.    if (u_reduce_video_profile(profile) != PIPE_VIDEO_CODEC_MPEG12)
  528.       goto vl;
  529.    if (screen->device->chipset >= 0x98 && screen->device->chipset != 0xa0)
  530.       goto vl;
  531.  
  532.    dec = CALLOC_STRUCT(nouveau_decoder);
  533.    if (!dec)
  534.       return NULL;
  535.  
  536.    ret = nouveau_object_new(&screen->device->object, 0,
  537.                             NOUVEAU_FIFO_CHANNEL_CLASS,
  538.                             &nv04_data, sizeof(nv04_data), &dec->chan);
  539.    if (ret)
  540.       goto fail;
  541.    ret = nouveau_client_new(screen->device, &dec->client);
  542.    if (ret)
  543.       goto fail;
  544.    ret = nouveau_pushbuf_new(dec->client, dec->chan, 2, 4096, 1, &dec->push);
  545.    if (ret)
  546.       goto fail;
  547.    ret = nouveau_bufctx_new(dec->client, NV31_VIDEO_BIND_COUNT, &dec->bufctx);
  548.    if (ret)
  549.       goto fail;
  550.    push = dec->push;
  551.  
  552.    width = align(width, 64);
  553.    height = align(height, 64);
  554.  
  555.    if (is8274)
  556.       ret = nouveau_object_new(dec->chan, 0xbeef8274, NV84_MPEG_CLASS, NULL, 0,
  557.                                &mpeg);
  558.    else
  559.       ret = nouveau_object_new(dec->chan, 0xbeef3174, NV31_MPEG_CLASS, NULL, 0,
  560.                                &mpeg);
  561.    if (ret < 0) {
  562.       debug_printf("Creation failed: %s (%i)\n", strerror(-ret), ret);
  563.       return NULL;
  564.    }
  565.  
  566.    dec->mpeg = mpeg;
  567.    dec->base.context = context;
  568.    dec->base.profile = profile;
  569.    dec->base.entrypoint = entrypoint;
  570.    dec->base.chroma_format = chroma_format;
  571.    dec->base.width = width;
  572.    dec->base.height = height;
  573.    dec->base.max_references = max_references;
  574.    dec->base.destroy = nouveau_decoder_destroy;
  575.    dec->base.begin_frame = nouveau_decoder_begin_frame;
  576.    dec->base.decode_macroblock = nouveau_decoder_decode_macroblock;
  577.    dec->base.end_frame = nouveau_decoder_end_frame;
  578.    dec->base.flush = nouveau_decoder_flush;
  579.    dec->screen = screen;
  580.  
  581.    ret = nouveau_bo_new(dec->screen->device, NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
  582.                         0, 1024 * 1024, NULL, &dec->cmd_bo);
  583.    if (ret)
  584.       goto fail;
  585.  
  586.    ret = nouveau_bo_new(dec->screen->device, NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
  587.                         0, width * height * 6, NULL, &dec->data_bo);
  588.    if (ret)
  589.       goto fail;
  590.  
  591.    /* we don't need the fence, the kernel sync's for us */
  592. #if 0
  593.    ret = nouveau_bo_new(dec->screen->device, NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
  594.                         0, 4096, NULL, &dec->fence_bo);
  595.    if (ret)
  596.       goto fail;
  597.    nouveau_bo_map(dec->fence_bo, NOUVEAU_BO_RDWR, NULL);
  598.    dec->fence_map = dec->fence_bo->map;
  599.    dec->fence_map[0] = 0;
  600. #endif
  601.  
  602.    nouveau_pushbuf_bufctx(dec->push, dec->bufctx);
  603.    nouveau_pushbuf_space(push, 32, 4, 0);
  604.  
  605.    BEGIN_NV04(push, SUBC_MPEG(NV01_SUBCHAN_OBJECT), 1);
  606.    PUSH_DATA (push, dec->mpeg->handle);
  607.  
  608.    BEGIN_NV04(push, NV31_MPEG(DMA_CMD), 1);
  609.    PUSH_DATA (push, nv04_data.gart);
  610.  
  611.    BEGIN_NV04(push, NV31_MPEG(DMA_DATA), 1);
  612.    PUSH_DATA (push, nv04_data.gart);
  613.  
  614.    BEGIN_NV04(push, NV31_MPEG(DMA_IMAGE), 1);
  615.    PUSH_DATA (push, nv04_data.vram);
  616.  
  617.    BEGIN_NV04(push, NV31_MPEG(PITCH), 2);
  618.    PUSH_DATA (push, width | NV31_MPEG_PITCH_UNK);
  619.    PUSH_DATA (push, (height << NV31_MPEG_SIZE_H__SHIFT) | width);
  620.  
  621.    BEGIN_NV04(push, NV31_MPEG(FORMAT), 2);
  622.    PUSH_DATA (push, 0);
  623.    switch (entrypoint) {
  624.       case PIPE_VIDEO_ENTRYPOINT_BITSTREAM: PUSH_DATA (push, 0x100); break;
  625.       case PIPE_VIDEO_ENTRYPOINT_IDCT: PUSH_DATA (push, 1); break;
  626.       case PIPE_VIDEO_ENTRYPOINT_MC: PUSH_DATA (push, 0); break;
  627.       default: assert(0);
  628.    }
  629.  
  630.    if (is8274) {
  631.       BEGIN_NV04(push, NV84_MPEG(DMA_QUERY), 1);
  632.       PUSH_DATA (push, nv04_data.vram);
  633. #if 0
  634.       BEGIN_NV04(push, NV84_MPEG(QUERY_OFFSET), 2);
  635.       PUSH_DATA (push, dec->fence_bo->offset);
  636.       PUSH_DATA (push, dec->fence_seq);
  637. #endif
  638.    }
  639.  
  640.    ret = nouveau_vpe_init(dec);
  641.    if (ret)
  642.       goto fail;
  643.    nouveau_vpe_fini(dec);
  644.    return &dec->base;
  645.  
  646. fail:
  647.    nouveau_decoder_destroy(&dec->base);
  648.    return NULL;
  649.  
  650. vl:
  651.    debug_printf("Using g3dvl renderer\n");
  652.    return vl_create_decoder(context, profile, entrypoint,
  653.                             chroma_format, width, height,
  654.                             max_references, expect_chunked_decode);
  655. }
  656.  
  657. static struct pipe_sampler_view **
  658. nouveau_video_buffer_sampler_view_planes(struct pipe_video_buffer *buffer)
  659. {
  660.    struct nouveau_video_buffer *buf = (struct nouveau_video_buffer *)buffer;
  661.    struct pipe_sampler_view sv_templ;
  662.    struct pipe_context *pipe;
  663.    unsigned i;
  664.  
  665.    assert(buf);
  666.  
  667.    pipe = buf->base.context;
  668.  
  669.    for (i = 0; i < buf->num_planes; ++i ) {
  670.       if (!buf->sampler_view_planes[i]) {
  671.          memset(&sv_templ, 0, sizeof(sv_templ));
  672.          u_sampler_view_default_template(&sv_templ, buf->resources[i], buf->resources[i]->format);
  673.  
  674.          if (util_format_get_nr_components(buf->resources[i]->format) == 1)
  675.             sv_templ.swizzle_r = sv_templ.swizzle_g = sv_templ.swizzle_b = sv_templ.swizzle_a = PIPE_SWIZZLE_RED;
  676.  
  677.          buf->sampler_view_planes[i] = pipe->create_sampler_view(pipe, buf->resources[i], &sv_templ);
  678.          if (!buf->sampler_view_planes[i])
  679.             goto error;
  680.       }
  681.    }
  682.  
  683.    return buf->sampler_view_planes;
  684.  
  685. error:
  686.    for (i = 0; i < buf->num_planes; ++i )
  687.       pipe_sampler_view_reference(&buf->sampler_view_planes[i], NULL);
  688.  
  689.    return NULL;
  690. }
  691.  
  692. static struct pipe_sampler_view **
  693. nouveau_video_buffer_sampler_view_components(struct pipe_video_buffer *buffer)
  694. {
  695.    struct nouveau_video_buffer *buf = (struct nouveau_video_buffer *)buffer;
  696.    struct pipe_sampler_view sv_templ;
  697.    struct pipe_context *pipe;
  698.    unsigned i, j, component;
  699.  
  700.    assert(buf);
  701.  
  702.    pipe = buf->base.context;
  703.  
  704.    for (component = 0, i = 0; i < buf->num_planes; ++i ) {
  705.       unsigned nr_components = util_format_get_nr_components(buf->resources[i]->format);
  706.  
  707.       for (j = 0; j < nr_components; ++j, ++component) {
  708.          assert(component < VL_NUM_COMPONENTS);
  709.  
  710.          if (!buf->sampler_view_components[component]) {
  711.             memset(&sv_templ, 0, sizeof(sv_templ));
  712.             u_sampler_view_default_template(&sv_templ, buf->resources[i], buf->resources[i]->format);
  713.             sv_templ.swizzle_r = sv_templ.swizzle_g = sv_templ.swizzle_b = PIPE_SWIZZLE_RED + j;
  714.             sv_templ.swizzle_a = PIPE_SWIZZLE_ONE;
  715.             buf->sampler_view_components[component] = pipe->create_sampler_view(pipe, buf->resources[i], &sv_templ);
  716.             if (!buf->sampler_view_components[component])
  717.                goto error;
  718.          }
  719.       }
  720.    }
  721.  
  722.    return buf->sampler_view_components;
  723.  
  724. error:
  725.    for (i = 0; i < 3; ++i )
  726.       pipe_sampler_view_reference(&buf->sampler_view_components[i], NULL);
  727.  
  728.    return NULL;
  729. }
  730.  
  731. static struct pipe_surface **
  732. nouveau_video_buffer_surfaces(struct pipe_video_buffer *buffer)
  733. {
  734.    struct nouveau_video_buffer *buf = (struct nouveau_video_buffer *)buffer;
  735.    struct pipe_surface surf_templ;
  736.    struct pipe_context *pipe;
  737.    unsigned i;
  738.  
  739.    assert(buf);
  740.  
  741.    pipe = buf->base.context;
  742.  
  743.    for (i = 0; i < buf->num_planes; ++i ) {
  744.       if (!buf->surfaces[i]) {
  745.          memset(&surf_templ, 0, sizeof(surf_templ));
  746.          surf_templ.format = buf->resources[i]->format;
  747.          buf->surfaces[i] = pipe->create_surface(pipe, buf->resources[i], &surf_templ);
  748.          if (!buf->surfaces[i])
  749.             goto error;
  750.       }
  751.    }
  752.  
  753.    return buf->surfaces;
  754.  
  755. error:
  756.    for (i = 0; i < buf->num_planes; ++i )
  757.       pipe_surface_reference(&buf->surfaces[i], NULL);
  758.  
  759.    return NULL;
  760. }
  761.  
  762. static void
  763. nouveau_video_buffer_destroy(struct pipe_video_buffer *buffer)
  764. {
  765.    struct nouveau_video_buffer *buf = (struct nouveau_video_buffer *)buffer;
  766.    unsigned i;
  767.  
  768.    assert(buf);
  769.  
  770.    for (i = 0; i < buf->num_planes; ++i) {
  771.       pipe_surface_reference(&buf->surfaces[i], NULL);
  772.       pipe_sampler_view_reference(&buf->sampler_view_planes[i], NULL);
  773.       pipe_sampler_view_reference(&buf->sampler_view_components[i], NULL);
  774.       pipe_resource_reference(&buf->resources[i], NULL);
  775.    }
  776.    for (;i < 3;++i)
  777.       pipe_sampler_view_reference(&buf->sampler_view_components[i], NULL);
  778.  
  779.    FREE(buffer);
  780. }
  781.  
  782. static struct pipe_video_buffer *
  783. nouveau_video_buffer_create(struct pipe_context *pipe,
  784.                             struct nouveau_screen *screen,
  785.                             const struct pipe_video_buffer *templat)
  786. {
  787.    struct nouveau_video_buffer *buffer;
  788.    struct pipe_resource templ;
  789.    unsigned width, height;
  790.  
  791.    /* Only do a linear surface when a hardware decoder is used
  792.     * hardware decoder is only supported on some chipsets
  793.     * and it only supports the NV12 format
  794.     */
  795.    if (templat->buffer_format != PIPE_FORMAT_NV12 || getenv("XVMC_VL") ||
  796.        (screen->device->chipset >= 0x98 && screen->device->chipset != 0xa0))
  797.       return vl_video_buffer_create(pipe, templat);
  798.  
  799.    assert(templat->chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420);
  800.    width = align(templat->width, 64);
  801.    height = align(templat->height, 64);
  802.  
  803.    buffer = CALLOC_STRUCT(nouveau_video_buffer);
  804.    if (!buffer)
  805.       return NULL;
  806.  
  807.    buffer->base.context = pipe;
  808.    buffer->base.destroy = nouveau_video_buffer_destroy;
  809.    buffer->base.get_sampler_view_planes = nouveau_video_buffer_sampler_view_planes;
  810.    buffer->base.get_sampler_view_components = nouveau_video_buffer_sampler_view_components;
  811.    buffer->base.get_surfaces = nouveau_video_buffer_surfaces;
  812.    buffer->base.chroma_format = templat->chroma_format;
  813.    buffer->base.width = width;
  814.    buffer->base.height = height;
  815.    buffer->num_planes = 2;
  816.  
  817.    memset(&templ, 0, sizeof(templ));
  818.    templ.target = PIPE_TEXTURE_2D;
  819.    templ.format = PIPE_FORMAT_R8_UNORM;
  820.    templ.width0 = width;
  821.    templ.height0 = height;
  822.    templ.depth0 = 1;
  823.    templ.array_size = 1;
  824.    templ.bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
  825.    templ.usage = PIPE_USAGE_STATIC;
  826.    templ.flags = NOUVEAU_RESOURCE_FLAG_LINEAR;
  827.  
  828.    buffer->resources[0] = pipe->screen->resource_create(pipe->screen, &templ);
  829.    if (!buffer->resources[0])
  830.       goto error;
  831.    templ.width0 /= 2;
  832.    templ.height0 /= 2;
  833.    templ.format = PIPE_FORMAT_R8G8_UNORM;
  834.    buffer->resources[1] = pipe->screen->resource_create(pipe->screen, &templ);
  835.    if (!buffer->resources[1])
  836.       goto error;
  837.    return &buffer->base;
  838.  
  839. error:
  840.    nouveau_video_buffer_destroy(&buffer->base);
  841.    return NULL;
  842. }
  843.  
  844. static int
  845. nouveau_screen_get_video_param(struct pipe_screen *pscreen,
  846.                                enum pipe_video_profile profile,
  847.                                enum pipe_video_cap param)
  848. {
  849.    switch (param) {
  850.    case PIPE_VIDEO_CAP_SUPPORTED:
  851.       return vl_profile_supported(pscreen, profile);
  852.    case PIPE_VIDEO_CAP_NPOT_TEXTURES:
  853.       return 1;
  854.    case PIPE_VIDEO_CAP_MAX_WIDTH:
  855.    case PIPE_VIDEO_CAP_MAX_HEIGHT:
  856.       return vl_video_buffer_max_size(pscreen);
  857.    case PIPE_VIDEO_CAP_PREFERED_FORMAT:
  858.       return PIPE_FORMAT_NV12;
  859.    case PIPE_VIDEO_CAP_PREFERS_INTERLACED:
  860.       return false;
  861.    case PIPE_VIDEO_CAP_SUPPORTS_INTERLACED:
  862.       return false;
  863.    case PIPE_VIDEO_CAP_SUPPORTS_PROGRESSIVE:
  864.       return true;
  865.    default:
  866.       debug_printf("unknown video param: %d\n", param);
  867.       return 0;
  868.    }
  869. }
  870.  
  871. void
  872. nouveau_screen_init_vdec(struct nouveau_screen *screen)
  873. {
  874.    screen->base.get_video_param = nouveau_screen_get_video_param;
  875.    screen->base.is_video_format_supported = vl_video_buffer_is_format_supported;
  876. }
  877.  
  878. static struct pipe_video_decoder *
  879. nouveau_context_create_decoder(struct pipe_context *context,
  880.                                enum pipe_video_profile profile,
  881.                                enum pipe_video_entrypoint entrypoint,
  882.                                enum pipe_video_chroma_format chroma_format,
  883.                                unsigned width, unsigned height,
  884.                                unsigned max_references, bool expect_chunked_decode)
  885. {
  886.    struct nouveau_screen *screen = nouveau_context(context)->screen;
  887.    return nouveau_create_decoder(context, screen, profile, entrypoint,
  888.                                  chroma_format, width, height,
  889.                                  max_references, expect_chunked_decode);
  890. }
  891.  
  892. static struct pipe_video_buffer *
  893. nouveau_context_video_buffer_create(struct pipe_context *pipe,
  894.                                     const struct pipe_video_buffer *templat)
  895. {
  896.    struct nouveau_screen *screen = nouveau_context(pipe)->screen;
  897.    return nouveau_video_buffer_create(pipe, screen, templat);
  898. }
  899.  
  900. void
  901. nouveau_context_init_vdec(struct nouveau_context *nv)
  902. {
  903.    nv->pipe.create_video_decoder = nouveau_context_create_decoder;
  904.    nv->pipe.create_video_buffer = nouveau_context_video_buffer_create;
  905. }
  906.