vl_mpeg12_decoder.c revision 849bc838e81f930e6f090e6c6597bb92e822b4c9 
1/**************************************************************************
2 *
3 * Copyright 2009 Younes Manton.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28#include <math.h>
29#include <assert.h>
30
31#include <util/u_memory.h>
32#include <util/u_rect.h>
33#include <util/u_video.h>
34
35#include "vl_mpeg12_decoder.h"
36#include "vl_defines.h"
37
38#define SCALE_FACTOR_SNORM (32768.0f / 256.0f)
39#define SCALE_FACTOR_SSCALED (1.0f / 256.0f)
40
41static const unsigned const_empty_block_mask_420[3][2][2] = {
42   { { 0x20, 0x10 },  { 0x08, 0x04 } },
43   { { 0x02, 0x02 },  { 0x02, 0x02 } },
44   { { 0x01, 0x01 },  { 0x01, 0x01 } }
45};
46
47static const enum pipe_format const_idct_source_formats[] = {
48   PIPE_FORMAT_R16G16B16A16_SNORM,
49   PIPE_FORMAT_R16G16B16A16_SSCALED
50};
51
52static const unsigned num_idct_source_formats =
53   sizeof(const_idct_source_formats) / sizeof(enum pipe_format);
54
55static const enum pipe_format const_idct_intermediate_formats[] = {
56   PIPE_FORMAT_R16G16B16A16_FLOAT,
57   PIPE_FORMAT_R16G16B16A16_SNORM,
58   PIPE_FORMAT_R16G16B16A16_SSCALED,
59   PIPE_FORMAT_R32G32B32A32_FLOAT
60};
61
62static const unsigned num_idct_intermediate_formats =
63   sizeof(const_idct_intermediate_formats) / sizeof(enum pipe_format);
64
65static const enum pipe_format const_mc_source_formats[] = {
66   PIPE_FORMAT_R16_SNORM,
67   PIPE_FORMAT_R16_SSCALED
68};
69
70static const unsigned num_mc_source_formats =
71   sizeof(const_mc_source_formats) / sizeof(enum pipe_format);
72
73static void
74map_buffers(struct vl_mpeg12_decoder *ctx, struct vl_mpeg12_buffer *buffer)
75{
76   struct pipe_sampler_view **sampler_views;
77   struct pipe_resource *tex;
78   unsigned i;
79
80   assert(ctx && buffer);
81
82   if (ctx->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT)
83      sampler_views = buffer->idct_source->get_sampler_views(buffer->idct_source);
84   else
85      sampler_views = buffer->mc_source->get_sampler_views(buffer->mc_source);
86   assert(sampler_views);
87
88   for (i = 0; i < VL_MAX_PLANES; ++i) {
89      tex = sampler_views[i]->texture;
90
91      struct pipe_box rect =
92      {
93         0, 0, 0,
94         tex->width0,
95         tex->height0,
96         1
97      };
98
99      buffer->tex_transfer[i] = ctx->pipe->get_transfer
100      (
101         ctx->pipe, tex,
102         0, PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD,
103         &rect
104      );
105
106      buffer->texels[i] = ctx->pipe->transfer_map(ctx->pipe, buffer->tex_transfer[i]);
107   }
108}
109
110static void
111upload_block(struct vl_mpeg12_buffer *buffer, unsigned plane, unsigned x, unsigned y, short *block)
112{
113   unsigned tex_pitch;
114   short *texels;
115
116   unsigned i;
117
118   assert(buffer);
119   assert(block);
120
121   tex_pitch = buffer->tex_transfer[plane]->stride / sizeof(short);
122   texels = buffer->texels[plane] + y * tex_pitch * BLOCK_HEIGHT + x * BLOCK_WIDTH;
123
124   for (i = 0; i < BLOCK_HEIGHT; ++i)
125      memcpy(texels + i * tex_pitch, block + i * BLOCK_WIDTH, BLOCK_WIDTH * sizeof(short));
126}
127
128static void
129upload_buffer(struct vl_mpeg12_decoder *ctx,
130              struct vl_mpeg12_buffer *buffer,
131              struct pipe_mpeg12_macroblock *mb)
132{
133   short *blocks;
134   unsigned tb, x, y;
135
136   assert(ctx);
137   assert(buffer);
138   assert(mb);
139
140   blocks = mb->blocks;
141
142   for (y = 0; y < 2; ++y) {
143      for (x = 0; x < 2; ++x, ++tb) {
144         if (mb->cbp & (*ctx->empty_block_mask)[0][y][x]) {
145            upload_block(buffer, 0, mb->mbx * 2 + x, mb->mby * 2 + y, blocks);
146            blocks += BLOCK_WIDTH * BLOCK_HEIGHT;
147         }
148      }
149   }
150
151   /* TODO: Implement 422, 444 */
152   assert(ctx->base.chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420);
153
154   for (tb = 1; tb < 3; ++tb) {
155      if (mb->cbp & (*ctx->empty_block_mask)[tb][0][0]) {
156         upload_block(buffer, tb, mb->mbx, mb->mby, blocks);
157         blocks += BLOCK_WIDTH * BLOCK_HEIGHT;
158      }
159   }
160}
161
162static void
163unmap_buffers(struct vl_mpeg12_decoder *ctx, struct vl_mpeg12_buffer *buffer)
164{
165   unsigned i;
166
167   assert(ctx && buffer);
168
169   for (i = 0; i < VL_MAX_PLANES; ++i) {
170      ctx->pipe->transfer_unmap(ctx->pipe, buffer->tex_transfer[i]);
171      ctx->pipe->transfer_destroy(ctx->pipe, buffer->tex_transfer[i]);
172   }
173}
174
175static void
176cleanup_idct_buffer(struct vl_mpeg12_buffer *buf)
177{
178   struct vl_mpeg12_decoder *dec;
179   assert(buf);
180
181   dec = (struct vl_mpeg12_decoder*)buf->base.decoder;
182   assert(dec);
183
184   buf->idct_source->destroy(buf->idct_source);
185   buf->idct_intermediate->destroy(buf->idct_intermediate);
186   vl_idct_cleanup_buffer(&dec->idct_y, &buf->idct[0]);
187   vl_idct_cleanup_buffer(&dec->idct_c, &buf->idct[1]);
188   vl_idct_cleanup_buffer(&dec->idct_c, &buf->idct[2]);
189}
190
191static void
192vl_mpeg12_buffer_destroy(struct pipe_video_decode_buffer *buffer)
193{
194   struct vl_mpeg12_buffer *buf = (struct vl_mpeg12_buffer*)buffer;
195   struct vl_mpeg12_decoder *dec;
196   unsigned i;
197
198   assert(buf);
199
200   dec = (struct vl_mpeg12_decoder*)buf->base.decoder;
201   assert(dec);
202
203   if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT)
204      cleanup_idct_buffer(buf);
205
206   buf->mc_source->destroy(buf->mc_source);
207   vl_vb_cleanup(&buf->vertex_stream);
208   for (i = 0; i < VL_MAX_PLANES; ++i)
209      vl_mc_cleanup_buffer(&buf->mc[i]);
210
211   FREE(buf);
212}
213
214static void
215vl_mpeg12_buffer_map(struct pipe_video_decode_buffer *buffer)
216{
217   struct vl_mpeg12_buffer *buf = (struct vl_mpeg12_buffer*)buffer;
218   struct vl_mpeg12_decoder *dec;
219   assert(buf);
220
221   dec = (struct vl_mpeg12_decoder *)buf->base.decoder;
222   assert(dec);
223
224   vl_vb_map(&buf->vertex_stream, dec->pipe);
225   map_buffers(dec, buf);
226}
227
228static void
229vl_mpeg12_buffer_add_macroblocks(struct pipe_video_decode_buffer *buffer,
230                                 unsigned num_macroblocks,
231                                 struct pipe_macroblock *macroblocks)
232{
233   struct pipe_mpeg12_macroblock *mb = (struct pipe_mpeg12_macroblock*)macroblocks;
234   struct vl_mpeg12_buffer *buf = (struct vl_mpeg12_buffer*)buffer;
235   struct vl_mpeg12_decoder *dec;
236   unsigned i;
237
238   assert(buf);
239
240   dec =  (struct vl_mpeg12_decoder*)buf->base.decoder;
241   assert(dec);
242
243   assert(num_macroblocks);
244   assert(macroblocks);
245   assert(macroblocks->codec == PIPE_VIDEO_CODEC_MPEG12);
246
247   for ( i = 0; i < num_macroblocks; ++i ) {
248      vl_vb_add_block(&buf->vertex_stream, &mb[i], dec->empty_block_mask);
249      upload_buffer(dec, buf, &mb[i]);
250   }
251}
252
253static void
254vl_mpeg12_buffer_unmap(struct pipe_video_decode_buffer *buffer)
255{
256   struct vl_mpeg12_buffer *buf = (struct vl_mpeg12_buffer*)buffer;
257   struct vl_mpeg12_decoder *dec;
258   assert(buf);
259
260   dec = (struct vl_mpeg12_decoder *)buf->base.decoder;
261   assert(dec);
262
263   vl_vb_unmap(&buf->vertex_stream, dec->pipe);
264   unmap_buffers(dec, buf);
265}
266
267static void
268vl_mpeg12_destroy(struct pipe_video_decoder *decoder)
269{
270   struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder*)decoder;
271
272   assert(decoder);
273
274   /* Asserted in softpipe_delete_fs_state() for some reason */
275   dec->pipe->bind_vs_state(dec->pipe, NULL);
276   dec->pipe->bind_fs_state(dec->pipe, NULL);
277
278   dec->pipe->delete_depth_stencil_alpha_state(dec->pipe, dec->dsa);
279
280   vl_mc_cleanup(&dec->mc_y);
281   vl_mc_cleanup(&dec->mc_c);
282
283   if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) {
284      vl_idct_cleanup(&dec->idct_y);
285      vl_idct_cleanup(&dec->idct_c);
286   }
287
288   dec->pipe->delete_vertex_elements_state(dec->pipe, dec->ves_ycbcr);
289   dec->pipe->delete_vertex_elements_state(dec->pipe, dec->ves_mv);
290
291   pipe_resource_reference(&dec->quads.buffer, NULL);
292   pipe_resource_reference(&dec->pos.buffer, NULL);
293
294   FREE(dec);
295}
296
297static bool
298init_idct_buffer(struct vl_mpeg12_buffer *buffer)
299{
300   enum pipe_format formats[3];
301
302   struct pipe_sampler_view **idct_source_sv, **idct_intermediate_sv;
303   struct pipe_surface **idct_surfaces;
304
305   struct vl_mpeg12_decoder *dec;
306
307   unsigned i;
308
309   assert(buffer);
310
311   dec = (struct vl_mpeg12_decoder*)buffer->base.decoder;
312
313   formats[0] = formats[1] = formats[2] = dec->idct_source_format;
314   buffer->idct_source = vl_video_buffer_init(dec->base.context, dec->pipe,
315                                              dec->base.width / 4, dec->base.height, 1,
316                                              dec->base.chroma_format,
317                                              formats, PIPE_USAGE_STREAM);
318   if (!buffer->idct_source)
319      goto error_source;
320
321   formats[0] = formats[1] = formats[2] = dec->idct_intermediate_format;
322   buffer->idct_intermediate = vl_video_buffer_init(dec->base.context, dec->pipe,
323                                                    dec->base.width / dec->nr_of_idct_render_targets,
324                                                    dec->base.height / 4, dec->nr_of_idct_render_targets,
325                                                    dec->base.chroma_format,
326                                                    formats, PIPE_USAGE_STATIC);
327
328   if (!buffer->idct_intermediate)
329      goto error_intermediate;
330
331   idct_source_sv = buffer->idct_source->get_sampler_views(buffer->idct_source);
332   if (!idct_source_sv)
333      goto error_source_sv;
334
335   idct_intermediate_sv = buffer->idct_intermediate->get_sampler_views(buffer->idct_intermediate);
336   if (!idct_intermediate_sv)
337      goto error_intermediate_sv;
338
339   idct_surfaces = buffer->mc_source->get_surfaces(buffer->mc_source);
340   if (!idct_surfaces)
341      goto error_surfaces;
342
343   for (i = 0; i < 3; ++i)
344      if (!vl_idct_init_buffer(i == 0 ? &dec->idct_y : &dec->idct_c,
345                               &buffer->idct[i], idct_source_sv[i],
346                               idct_intermediate_sv[i], idct_surfaces[i]))
347         goto error_plane;
348
349   return true;
350
351error_plane:
352   for (; i > 0; --i)
353      vl_idct_cleanup_buffer(i == 1 ? &dec->idct_c : &dec->idct_y, &buffer->idct[i - 1]);
354
355error_surfaces:
356error_intermediate_sv:
357error_source_sv:
358   buffer->idct_intermediate->destroy(buffer->idct_intermediate);
359
360error_intermediate:
361   buffer->idct_source->destroy(buffer->idct_source);
362
363error_source:
364   return false;
365}
366
367static struct pipe_video_decode_buffer *
368vl_mpeg12_create_buffer(struct pipe_video_decoder *decoder)
369{
370   enum pipe_format formats[3];
371
372   struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder*)decoder;
373   struct vl_mpeg12_buffer *buffer;
374
375   struct pipe_sampler_view **mc_source_sv;
376
377   assert(dec);
378
379   buffer = CALLOC_STRUCT(vl_mpeg12_buffer);
380   if (buffer == NULL)
381      return NULL;
382
383   buffer->base.decoder = decoder;
384   buffer->base.destroy = vl_mpeg12_buffer_destroy;
385   buffer->base.map = vl_mpeg12_buffer_map;
386   buffer->base.add_macroblocks = vl_mpeg12_buffer_add_macroblocks;
387   buffer->base.unmap = vl_mpeg12_buffer_unmap;
388
389   vl_vb_init(&buffer->vertex_stream, dec->pipe,
390              dec->base.width / MACROBLOCK_WIDTH,
391              dec->base.height / MACROBLOCK_HEIGHT);
392
393   formats[0] = formats[1] = formats[2] =dec->mc_source_format;
394   buffer->mc_source = vl_video_buffer_init(dec->base.context, dec->pipe,
395                                            dec->base.width, dec->base.height, 1,
396                                            dec->base.chroma_format,
397                                            formats, PIPE_USAGE_STATIC);
398
399   if (!buffer->mc_source)
400      goto error_mc_source;
401
402   if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT)
403      if (!init_idct_buffer(buffer))
404         goto error_idct;
405
406   mc_source_sv = buffer->mc_source->get_sampler_views(buffer->mc_source);
407   if (!mc_source_sv)
408      goto error_mc_source_sv;
409
410   if(!vl_mc_init_buffer(&dec->mc_y, &buffer->mc[0], mc_source_sv[0]))
411      goto error_mc_y;
412
413   if(!vl_mc_init_buffer(&dec->mc_c, &buffer->mc[1], mc_source_sv[1]))
414      goto error_mc_cb;
415
416   if(!vl_mc_init_buffer(&dec->mc_c, &buffer->mc[2], mc_source_sv[2]))
417      goto error_mc_cr;
418
419   return &buffer->base;
420
421error_mc_cr:
422   vl_mc_cleanup_buffer(&buffer->mc[1]);
423
424error_mc_cb:
425   vl_mc_cleanup_buffer(&buffer->mc[0]);
426
427error_mc_y:
428error_mc_source_sv:
429   if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT)
430      cleanup_idct_buffer(buffer);
431
432error_idct:
433   buffer->mc_source->destroy(buffer->mc_source);
434
435error_mc_source:
436   vl_vb_cleanup(&buffer->vertex_stream);
437
438error_vertex_stream:
439   FREE(buffer);
440   return NULL;
441}
442
443static void
444vl_mpeg12_decoder_flush_buffer(struct pipe_video_decode_buffer *buffer,
445                               struct pipe_video_buffer *refs[2],
446                               struct pipe_video_buffer *dst,
447                               struct pipe_fence_handle **fence)
448{
449   struct vl_mpeg12_buffer *buf = (struct vl_mpeg12_buffer *)buffer;
450   struct vl_mpeg12_decoder *dec;
451
452   struct pipe_sampler_view **sv[2];
453   struct pipe_surface **surfaces;
454
455   struct pipe_vertex_buffer vb[3];
456
457   unsigned i, j;
458
459   assert(buf);
460
461   dec = (struct vl_mpeg12_decoder *)buf->base.decoder;
462   assert(dec);
463
464   for (i = 0; i < 2; ++i)
465      sv[i] = refs[i] ? refs[i]->get_sampler_views(refs[i]) : NULL;
466
467   surfaces = dst->get_surfaces(dst);
468
469   vb[0] = dec->quads;
470   vb[1] = dec->pos;
471
472   dec->pipe->bind_vertex_elements_state(dec->pipe, dec->ves_mv);
473   for (i = 0; i < VL_MAX_PLANES; ++i) {
474      vl_mc_set_surface(&buf->mc[i], surfaces[i]);
475
476      for (j = 0; j < 2; ++j) {
477         if (sv[j] == NULL) continue;
478
479         vb[2] = vl_vb_get_mv(&buf->vertex_stream, j);;
480         dec->pipe->set_vertex_buffers(dec->pipe, 3, vb);
481
482         vl_mc_render_ref(&buf->mc[i], sv[j][i]);
483      }
484   }
485
486   dec->pipe->bind_vertex_elements_state(dec->pipe, dec->ves_ycbcr);
487   for (i = 0; i < VL_MAX_PLANES; ++i) {
488      unsigned num_instances = vl_vb_restart(&buf->vertex_stream, i);
489
490      vb[1] = vl_vb_get_ycbcr(&buf->vertex_stream, i);
491      dec->pipe->set_vertex_buffers(dec->pipe, 2, vb);
492
493      if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT)
494         vl_idct_flush(i == 0 ? &dec->idct_y : &dec->idct_c, &buf->idct[i], num_instances);
495
496      vl_mc_render_ycbcr(&buf->mc[i], num_instances);
497   }
498
499   dec->pipe->flush(dec->pipe, fence);
500}
501
502static void
503vl_mpeg12_decoder_clear_buffer(struct pipe_video_decode_buffer *buffer)
504{
505   struct vl_mpeg12_buffer *buf = (struct vl_mpeg12_buffer *)buffer;
506   unsigned i;
507
508   assert(buf);
509
510   for (i = 0; i < VL_MAX_PLANES; ++i)
511      vl_vb_restart(&buf->vertex_stream, i);
512}
513
514static bool
515init_pipe_state(struct vl_mpeg12_decoder *dec)
516{
517   struct pipe_depth_stencil_alpha_state dsa;
518   unsigned i;
519
520   assert(dec);
521
522   memset(&dsa, 0, sizeof dsa);
523   dsa.depth.enabled = 0;
524   dsa.depth.writemask = 0;
525   dsa.depth.func = PIPE_FUNC_ALWAYS;
526   for (i = 0; i < 2; ++i) {
527      dsa.stencil[i].enabled = 0;
528      dsa.stencil[i].func = PIPE_FUNC_ALWAYS;
529      dsa.stencil[i].fail_op = PIPE_STENCIL_OP_KEEP;
530      dsa.stencil[i].zpass_op = PIPE_STENCIL_OP_KEEP;
531      dsa.stencil[i].zfail_op = PIPE_STENCIL_OP_KEEP;
532      dsa.stencil[i].valuemask = 0;
533      dsa.stencil[i].writemask = 0;
534   }
535   dsa.alpha.enabled = 0;
536   dsa.alpha.func = PIPE_FUNC_ALWAYS;
537   dsa.alpha.ref_value = 0;
538   dec->dsa = dec->pipe->create_depth_stencil_alpha_state(dec->pipe, &dsa);
539   dec->pipe->bind_depth_stencil_alpha_state(dec->pipe, dec->dsa);
540
541   return true;
542}
543
544static enum pipe_format
545find_first_supported_format(struct vl_mpeg12_decoder *dec,
546                            const enum pipe_format formats[],
547                            unsigned num_formats,
548                            enum pipe_texture_target target)
549{
550   struct pipe_screen *screen;
551   unsigned i;
552
553   assert(dec);
554
555   screen = dec->pipe->screen;
556
557   for (i = 0; i < num_formats; ++i)
558      if (screen->is_format_supported(dec->pipe->screen, formats[i], target, 1,
559                                      PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET))
560         return formats[i];
561
562   return PIPE_FORMAT_NONE;
563}
564
565static bool
566init_idct(struct vl_mpeg12_decoder *dec, unsigned buffer_width, unsigned buffer_height)
567{
568   unsigned chroma_width, chroma_height, chroma_blocks_x, chroma_blocks_y;
569   struct pipe_sampler_view *matrix, *transpose;
570   float matrix_scale, transpose_scale;
571
572   dec->nr_of_idct_render_targets = dec->pipe->screen->get_param(dec->pipe->screen, PIPE_CAP_MAX_RENDER_TARGETS);
573
574   // more than 4 render targets usually doesn't makes any seens
575   dec->nr_of_idct_render_targets = MIN2(dec->nr_of_idct_render_targets, 4);
576
577   dec->idct_source_format = find_first_supported_format(dec, const_idct_source_formats,
578                                                         num_idct_source_formats, PIPE_TEXTURE_2D);
579
580   if (dec->idct_source_format == PIPE_FORMAT_NONE)
581      return false;
582
583   dec->idct_intermediate_format = find_first_supported_format(dec, const_idct_intermediate_formats,
584                                                               num_idct_intermediate_formats, PIPE_TEXTURE_3D);
585
586   if (dec->idct_intermediate_format == PIPE_FORMAT_NONE)
587      return false;
588
589   switch (dec->idct_source_format) {
590   case PIPE_FORMAT_R16G16B16A16_SSCALED:
591      matrix_scale = SCALE_FACTOR_SSCALED;
592      break;
593
594   case PIPE_FORMAT_R16G16B16A16_SNORM:
595      matrix_scale = SCALE_FACTOR_SNORM;
596      break;
597
598   default:
599      assert(0);
600      return false;
601   }
602
603   if (dec->idct_intermediate_format == PIPE_FORMAT_R16G16B16A16_FLOAT ||
604       dec->idct_intermediate_format == PIPE_FORMAT_R32G32B32A32_FLOAT)
605      transpose_scale = 1.0f;
606   else
607      transpose_scale = matrix_scale = sqrt(matrix_scale);
608
609   if (dec->mc_source_format == PIPE_FORMAT_R16_SSCALED)
610      transpose_scale /= SCALE_FACTOR_SSCALED;
611
612   if (!(matrix = vl_idct_upload_matrix(dec->pipe, matrix_scale)))
613      goto error_matrix;
614
615   if (matrix_scale != transpose_scale) {
616      if (!(transpose = vl_idct_upload_matrix(dec->pipe, transpose_scale)))
617         goto error_transpose;
618   } else
619      pipe_sampler_view_reference(&transpose, matrix);
620
621   if (!vl_idct_init(&dec->idct_y, dec->pipe, buffer_width, buffer_height,
622                     2, 2, dec->nr_of_idct_render_targets, matrix, transpose))
623      goto error_y;
624
625   if (dec->base.chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420) {
626      chroma_width = buffer_width / 2;
627      chroma_height = buffer_height / 2;
628      chroma_blocks_x = 1;
629      chroma_blocks_y = 1;
630   } else if (dec->base.chroma_format == PIPE_VIDEO_CHROMA_FORMAT_422) {
631      chroma_width = buffer_width;
632      chroma_height = buffer_height / 2;
633      chroma_blocks_x = 2;
634      chroma_blocks_y = 1;
635   } else {
636      chroma_width = buffer_width;
637      chroma_height = buffer_height;
638      chroma_blocks_x = 2;
639      chroma_blocks_y = 2;
640   }
641
642   if(!vl_idct_init(&dec->idct_c, dec->pipe, chroma_width, chroma_height,
643                    chroma_blocks_x, chroma_blocks_y,
644                    dec->nr_of_idct_render_targets, matrix, transpose))
645      goto error_c;
646
647   pipe_sampler_view_reference(&matrix, NULL);
648   pipe_sampler_view_reference(&transpose, NULL);
649   return true;
650
651error_c:
652   vl_idct_cleanup(&dec->idct_y);
653
654error_y:
655   pipe_sampler_view_reference(&transpose, NULL);
656
657error_transpose:
658   pipe_sampler_view_reference(&matrix, NULL);
659
660error_matrix:
661   return false;
662}
663
664struct pipe_video_decoder *
665vl_create_mpeg12_decoder(struct pipe_video_context *context,
666                         struct pipe_context *pipe,
667                         enum pipe_video_profile profile,
668                         enum pipe_video_entrypoint entrypoint,
669                         enum pipe_video_chroma_format chroma_format,
670                         unsigned width, unsigned height)
671{
672   struct vl_mpeg12_decoder *dec;
673   float mc_scale;
674
675   assert(u_reduce_video_profile(profile) == PIPE_VIDEO_CODEC_MPEG12);
676
677   dec = CALLOC_STRUCT(vl_mpeg12_decoder);
678
679   if (!dec)
680      return NULL;
681
682   dec->base.context = context;
683   dec->base.profile = profile;
684   dec->base.entrypoint = entrypoint;
685   dec->base.chroma_format = chroma_format;
686   dec->base.width = width;
687   dec->base.height = height;
688
689   dec->base.destroy = vl_mpeg12_destroy;
690   dec->base.create_buffer = vl_mpeg12_create_buffer;
691   dec->base.flush_buffer = vl_mpeg12_decoder_flush_buffer;
692   dec->base.clear_buffer = vl_mpeg12_decoder_clear_buffer;
693
694   dec->base.width = align(width, MACROBLOCK_WIDTH);
695   dec->base.height = align(height, MACROBLOCK_HEIGHT);
696
697   dec->pipe = pipe;
698
699   dec->quads = vl_vb_upload_quads(dec->pipe, 2, 2);
700   dec->pos = vl_vb_upload_pos(
701      dec->pipe,
702      dec->base.width / MACROBLOCK_WIDTH,
703      dec->base.height / MACROBLOCK_HEIGHT
704   );
705
706   dec->ves_ycbcr = vl_vb_get_ves_ycbcr(dec->pipe);
707   dec->ves_mv = vl_vb_get_ves_mv(dec->pipe);
708
709   /* TODO: Implement 422, 444 */
710   assert(dec->base.chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420);
711   dec->empty_block_mask = &const_empty_block_mask_420;
712
713   dec->mc_source_format = find_first_supported_format(dec, const_mc_source_formats,
714                                                       num_mc_source_formats, PIPE_TEXTURE_3D);
715
716   if (dec->mc_source_format == PIPE_FORMAT_NONE)
717      return NULL;
718
719   if (entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) {
720      if (!init_idct(dec, dec->base.width, dec->base.height))
721         goto error_idct;
722      if (dec->mc_source_format == PIPE_FORMAT_R16_SSCALED)
723         mc_scale = SCALE_FACTOR_SSCALED;
724      else
725         mc_scale = 1.0f;
726   } else {
727      switch (dec->mc_source_format) {
728      case PIPE_FORMAT_R16_SNORM:
729         mc_scale = SCALE_FACTOR_SNORM;
730         break;
731
732      case PIPE_FORMAT_R16_SSCALED:
733         mc_scale = SCALE_FACTOR_SSCALED;
734         break;
735
736      default:
737         assert(0);
738         return NULL;
739      }
740   }
741
742   if (!vl_mc_init(&dec->mc_y, dec->pipe, dec->base.width, dec->base.height, MACROBLOCK_HEIGHT, mc_scale))
743      goto error_mc_y;
744
745   // TODO
746   if (!vl_mc_init(&dec->mc_c, dec->pipe, dec->base.width, dec->base.height, BLOCK_HEIGHT, mc_scale))
747      goto error_mc_c;
748
749   if (!init_pipe_state(dec))
750      goto error_pipe_state;
751
752   return &dec->base;
753
754error_pipe_state:
755   vl_mc_cleanup(&dec->mc_c);
756
757error_mc_c:
758   vl_mc_cleanup(&dec->mc_y);
759
760error_mc_y:
761   if (entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) {
762      vl_idct_cleanup(&dec->idct_y);
763      vl_idct_cleanup(&dec->idct_c);
764   }
765
766error_idct:
767   FREE(dec);
768   return NULL;
769}
770