lxdream.org :: lxdream/src/pvr2/yuv.c r284:808617ee7135

tree revision 292:3b78f6d301b7

filename	src/pvr2/yuv.c
changeset	284:808617ee7135
prev	282:01e53698ff38
next	293:fe191b6381b5
author	nkeynes
date	Mon Jan 15 12:58:05 2007 +0000 (17 years ago)
permissions	-rw-r--r--
last change	Correct declaration of pvr2_vram64_read_stride

view

     1 /**

     2  * $Id: yuv.c,v 1.3 2007-01-15 08:32:09 nkeynes Exp $

     3  *

     4  * YUV420 and YUV422 decoding

     5  *

     6  * Copyright (c) 2005 Nathan Keynes.

     7  *

     8  * This program is free software; you can redistribute it and/or modify

     9  * it under the terms of the GNU General Public License as published by

    10  * the Free Software Foundation; either version 2 of the License, or

    11  * (at your option) any later version.

    12  *

    13  * This program is distributed in the hope that it will be useful,

    14  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    16  * GNU General Public License for more details.

    17  */

    18 #include "dream.h"

    19 #include "asic.h"

    20 #include "pvr2/pvr2.h"

    22 #define YUV420_BLOCK_SIZE 384

    23 #define YUV422_BLOCK_SIZE 512

    25 #define FORMAT_YUV420 0

    26 #define FORMAT_YUV422 1

    29 static int yuv_block_size[2] = { YUV420_BLOCK_SIZE, YUV422_BLOCK_SIZE };

    31 struct yuv_state {

    32     uint32_t target;

    33     int width;

    34     int height;

    35     int input_format;

    36     char data[512];

    37     int data_length;

    38     int x, y;

    39 } pvr2_yuv_state;

    41 /**

    42  * Transformation table for yuv420.

    43  */

    44 uint16_t yuv420_lut[512] = { 0, 128, 64, 129, 1, 130, 65, 131, 2, 132, 66, 133, 3, 134, 67, 135, 4, 192, 68, 193, 5, 194, 69, 195, 6, 196, 70, 197, 7, 198, 71, 199,

    45 			 0, 136, 64, 137, 1, 138, 65, 139, 2, 140, 66, 141, 3, 142, 67, 143, 4, 200, 68, 201, 5, 202, 69, 203, 6, 204, 70, 205, 7, 206, 71, 207,

    46 			 8, 144, 72, 145, 9, 146, 73, 147, 10, 148, 74, 149, 11, 150, 75, 151, 12, 208, 76, 209, 13, 210, 77, 211, 14, 212, 78, 213, 15, 214, 79, 215,

    47 			 8, 152, 72, 153, 9, 154, 73, 155, 10, 156, 74, 157, 11, 158, 75, 159, 12, 216, 76, 217, 13, 218, 77, 219, 14, 220, 78, 221, 15, 222, 79, 223,

    48 			 16, 160, 80, 161, 17, 162, 81, 163, 18, 164, 82, 165, 19, 166, 83, 167, 20, 224, 84, 225, 21, 226, 85, 227, 22, 228, 86, 229, 23, 230, 87, 231,

    49 			 16, 168, 80, 169, 17, 170, 81, 171, 18, 172, 82, 173, 19, 174, 83, 175, 20, 232, 84, 233, 21, 234, 85, 235, 22, 236, 86, 237, 23, 238, 87, 239,

    50 			 24, 176, 88, 177, 25, 178, 89, 179, 26, 180, 90, 181, 27, 182, 91, 183, 28, 240, 92, 241, 29, 242, 93, 243, 30, 244, 94, 245, 31, 246, 95, 247,

    51 			 24, 184, 88, 185, 25, 186, 89, 187, 26, 188, 90, 189, 27, 190, 91, 191, 28, 248, 92, 249, 29, 250, 93, 251, 30, 252, 94, 253, 31, 254, 95, 255,

    52 			 32, 256, 96, 257, 33, 258, 97, 259, 34, 260, 98, 261, 35, 262, 99, 263, 36, 320, 100, 321, 37, 322, 101, 323, 38, 324, 102, 325, 39, 326, 103, 327,

    53 			 32, 264, 96, 265, 33, 266, 97, 267, 34, 268, 98, 269, 35, 270, 99, 271, 36, 328, 100, 329, 37, 330, 101, 331, 38, 332, 102, 333, 39, 334, 103, 335,

    54 			 40, 272, 104, 273, 41, 274, 105, 275, 42, 276, 106, 277, 43, 278, 107, 279, 44, 336, 108, 337, 45, 338, 109, 339, 46, 340, 110, 341, 47, 342, 111, 343,

    55 			 40, 280, 104, 281, 41, 282, 105, 283, 42, 284, 106, 285, 43, 286, 107, 287, 44, 344, 108, 345, 45, 346, 109, 347, 46, 348, 110, 349, 47, 350, 111, 351,

    56 			 48, 288, 112, 289, 49, 290, 113, 291, 50, 292, 114, 293, 51, 294, 115, 295, 52, 352, 116, 353, 53, 354, 117, 355, 54, 356, 118, 357, 55, 358, 119, 359,

    57 			 48, 296, 112, 297, 49, 298, 113, 299, 50, 300, 114, 301, 51, 302, 115, 303, 52, 360, 116, 361, 53, 362, 117, 363, 54, 364, 118, 365, 55, 366, 119, 367,

    58 			 56, 304, 120, 305, 57, 306, 121, 307, 58, 308, 122, 309, 59, 310, 123, 311, 60, 368, 124, 369, 61, 370, 125, 371, 62, 372, 126, 373, 63, 374, 127, 375,

    59 			 56, 312, 120, 313, 57, 314, 121, 315, 58, 316, 122, 317, 59, 318, 123, 319, 60, 376, 124, 377, 61, 378, 125, 379, 62, 380, 126, 381, 63, 382, 127, 383 };

    62 /**

    63  * Input is 8x8 U, 8x8 V, 8x8 Y00, 8x8 Y01, 8x8 Y10, 8x8 Y11, 8 bits each,

    64  * for a total of 384 bytes.

    65  * Output is UVYV = 32 bits = 2 horizontal pixels, 8x16 = 512 bytes

    66  */

    67 void pvr2_decode_yuv420( char *dest, char *src )

    68 {

    69     int i;

    70     for( i=0; i<512; i++ ) {

    71 	dest[i] = src[yuv420_lut[i]];

    72     }

    73 }

    75 void pvr2_decode_yuv422( char *dest, char *src )

    76 {

    78 }

    80 /**

    81  * Process a single macroblock of YUV data and write it out to

    82  * texture vram.

    83  */

    84 void pvr2_yuv_process_block( char *data )

    85 {

    86     char output[512];

    88     if( pvr2_yuv_state.input_format == FORMAT_YUV420 ) {

    89 	pvr2_decode_yuv420( output, data );

    90     } else {

    91 	pvr2_decode_yuv422( output, data );

    92     }

    94     uint32_t target = pvr2_yuv_state.target +

    95 	(pvr2_yuv_state.y * pvr2_yuv_state.width * 512) +

    96 	(pvr2_yuv_state.x * 32);

    98     pvr2_vram64_write_stride( target, output, 32, pvr2_yuv_state.width*32, 16 );

    99     if( ++pvr2_yuv_state.x >= pvr2_yuv_state.width ) {

   100 	pvr2_yuv_state.x = 0;

   101 	pvr2_yuv_state.y++;

   102 	if( pvr2_yuv_state.y >= pvr2_yuv_state.height ) {

   103 	    asic_event( EVENT_PVR_YUV_DONE );

   104 	    pvr2_yuv_state.y = 0;

   105 	}

   106     }

   108     MMIO_WRITE( PVR2, YUV_COUNT, MMIO_READ( PVR2, YUV_COUNT ) + 1 );

   109 }

   111 /**

   112  * Receive data from the SH4, usually via DMA. This method is mainly responsible

   113  * for buffering the data into macroblock chunks and then passing it on to the

   114  * real processing

   115  */

   116 void pvr2_yuv_write( char *data, uint32_t length )

   117 {

   118     int block_size = yuv_block_size[pvr2_yuv_state.input_format];

   120     if( pvr2_yuv_state.data_length != 0 ) { /* Append to existing data */

   121 	int tmp = MIN( length, block_size - pvr2_yuv_state.data_length );

   122 	memcpy( pvr2_yuv_state.data + pvr2_yuv_state.data_length,

   123 		data, tmp );

   124 	pvr2_yuv_state.data_length += tmp;

   125 	data += tmp;

   126 	length -= tmp;

   127 	if( pvr2_yuv_state.data_length == block_size ) {

   128 	    pvr2_yuv_process_block( pvr2_yuv_state.data );

   129 	}

   130     }

   132     while( length >= block_size ) {

   133 	pvr2_yuv_process_block( data );

   134 	data += block_size;

   135 	length -= block_size;

   136     }

   138     if( length != 0 ) { /* Save the left over data */

   139 	memcpy( pvr2_yuv_state.data, data, length );

   140 	pvr2_yuv_state.data_length = length;

   141     }

   142 }

   144 void pvr2_yuv_init( uint32_t target )

   145 {

   146     pvr2_yuv_state.target = target;

   147     pvr2_yuv_state.x = 0;

   148     pvr2_yuv_state.y = 0;

   149     pvr2_yuv_state.data_length = 0;

   150     MMIO_WRITE( PVR2, YUV_COUNT, 0 );

   151 }

   153 void pvr2_yuv_set_config( uint32_t config )

   154 {

   155     pvr2_yuv_state.width = (config & 0x3f) + 1;

   156     pvr2_yuv_state.height = ((config>>8) & 0x3f) +1;

   157     pvr2_yuv_state.input_format = (config & 0x01000000) ? FORMAT_YUV422 : FORMAT_YUV420;

   158     if( config & 0x00010000 ) {

   159 	pvr2_yuv_state.height *= pvr2_yuv_state.width;

   160 	pvr2_yuv_state.width = 1;

   161     }

   162 }