projects / mesa.git / blob
? search:


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