1 /***************************************************************************
2 * Copyright (C) 2010 Gabriele Gorla *
3 * Copyright (C) 2007 Ryan Schultz, PCSX-df Team, PCSX team *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
19 ***************************************************************************/
23 /* memory speed is 1 byte per MDEC_BIAS psx clock
24 * That mean (PSXCLK / MDEC_BIAS) B/s
25 * MDEC_BIAS = 2.0 => ~16MB/s
26 * MDEC_BIAS = 3.0 => ~11MB/s
28 * I guess I have 50 images in 50Hz ... (could be 25 images ?)
29 * 320x240x24@50Hz => 11.52 MB/s
30 * 320x240x24@60Hz => 13.824 MB/s
31 * 320x240x16@50Hz => 7.68 MB/s
32 * 320x240x16@60Hz => 9.216 MB/s
33 * so 2.0 to 4.0 should be fine.
38 * <= 18 for "Disney's Treasure Planet"
43 #define DSIZE2 (DSIZE * DSIZE)
45 #define SCALE(x, n) ((x) >> (n))
46 #define SCALER(x, n) (((x) + ((1 << (n)) >> 1)) >> (n))
48 #define AAN_CONST_BITS 12
49 #define AAN_PRESCALE_BITS 16
51 #define AAN_CONST_SIZE 24
52 #define AAN_CONST_SCALE (AAN_CONST_SIZE - AAN_CONST_BITS)
54 #define AAN_PRESCALE_SIZE 20
55 #define AAN_PRESCALE_SCALE (AAN_PRESCALE_SIZE-AAN_PRESCALE_BITS)
58 #define FIX_1_082392200 SCALER(18159528, AAN_CONST_SCALE) // B6
59 #define FIX_1_414213562 SCALER(23726566, AAN_CONST_SCALE) // A4
60 #define FIX_1_847759065 SCALER(31000253, AAN_CONST_SCALE) // A2
61 #define FIX_2_613125930 SCALER(43840978, AAN_CONST_SCALE) // B2
63 #define MULS(var, const) (SCALE((var) * (const), AAN_CONST_BITS))
65 #define RLE_RUN(a) ((a) >> 10)
66 #define RLE_VAL(a) (((int)(a) << (sizeof(int) * 8 - 10)) >> (sizeof(int) * 8 - 10))
69 static void printmatrixu8(u8 *m) {
71 for(i = 0; i < DSIZE2; i++) {
73 if((i+1) % 8 == 0) printf("\n");
78 static inline void fillcol(int *blk, int val) {
79 blk[0 * DSIZE] = blk[1 * DSIZE] = blk[2 * DSIZE] = blk[3 * DSIZE]
80 = blk[4 * DSIZE] = blk[5 * DSIZE] = blk[6 * DSIZE] = blk[7 * DSIZE] = val;
83 static inline void fillrow(int *blk, int val) {
84 blk[0] = blk[1] = blk[2] = blk[3]
85 = blk[4] = blk[5] = blk[6] = blk[7] = val;
88 static void idct(int *block,int used_col) {
89 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
90 int z5, z10, z11, z12, z13;
94 // the block has only the DC coefficient
97 for (i = 0; i < DSIZE2; i++) block[i] = v;
101 // last_col keeps track of the highest column with non zero coefficients
103 for (i = 0; i < DSIZE; i++, ptr++) {
104 if ((used_col & (1 << i)) == 0) {
105 // the column is empty or has only the DC coefficient
106 if (ptr[DSIZE * 0]) {
107 fillcol(ptr, ptr[0]);
108 used_col |= (1 << i);
113 // further optimization could be made by keeping track of
114 // last_row in rl2blk
115 z10 = ptr[DSIZE * 0] + ptr[DSIZE * 4]; // s04
116 z11 = ptr[DSIZE * 0] - ptr[DSIZE * 4]; // d04
117 z13 = ptr[DSIZE * 2] + ptr[DSIZE * 6]; // s26
118 z12 = MULS(ptr[DSIZE * 2] - ptr[DSIZE * 6], FIX_1_414213562) - z13;
119 //^^^^ d26=d26*2*A4-s26
121 tmp0 = z10 + z13; // os07 = s04 + s26
122 tmp3 = z10 - z13; // os34 = s04 - s26
123 tmp1 = z11 + z12; // os16 = d04 + d26
124 tmp2 = z11 - z12; // os25 = d04 - d26
126 z13 = ptr[DSIZE * 3] + ptr[DSIZE * 5]; //s53
127 z10 = ptr[DSIZE * 3] - ptr[DSIZE * 5]; //-d53
128 z11 = ptr[DSIZE * 1] + ptr[DSIZE * 7]; //s17
129 z12 = ptr[DSIZE * 1] - ptr[DSIZE * 7]; //d17
131 tmp7 = z11 + z13; // od07 = s17 + s53
133 z5 = (z12 - z10) * (FIX_1_847759065);
134 tmp6 = SCALE(z10*(FIX_2_613125930) + z5, AAN_CONST_BITS) - tmp7;
135 tmp5 = MULS(z11 - z13, FIX_1_414213562) - tmp6;
136 tmp4 = SCALE(z12*(FIX_1_082392200) - z5, AAN_CONST_BITS) + tmp5;
139 //z5 = (z12 - z10)* FIX_1_847759065;
140 // tmp0 = (d17 + d53) * 2*A2
142 //tmp6 = DESCALE(z10*FIX_2_613125930 + z5, CONST_BITS) - tmp7;
143 // od16 = (d53*-2*B2 + tmp0) - od07
145 //tmp4 = DESCALE(z12*FIX_1_082392200 - z5, CONST_BITS) + tmp5;
146 // od34 = (d17*2*B6 - tmp0) + od25
150 // od34 = d17*2*(B6-A2) - d53*2*A2
151 // od16 = d53*2*(A2-B2) + d17*2*A2
155 // tmp5 = MULS(z11 - z13, FIX_1_414213562) - tmp6;
156 // od25 = (s17 - s53)*2*A4 - od16
158 ptr[DSIZE * 0] = (tmp0 + tmp7); // os07 + od07
159 ptr[DSIZE * 7] = (tmp0 - tmp7); // os07 - od07
160 ptr[DSIZE * 1] = (tmp1 + tmp6); // os16 + od16
161 ptr[DSIZE * 6] = (tmp1 - tmp6); // os16 - od16
162 ptr[DSIZE * 2] = (tmp2 + tmp5); // os25 + od25
163 ptr[DSIZE * 5] = (tmp2 - tmp5); // os25 - od25
164 ptr[DSIZE * 4] = (tmp3 + tmp4); // os34 + od34
165 ptr[DSIZE * 3] = (tmp3 - tmp4); // os34 - od34
170 for (i = 0; i < DSIZE; i++)
171 fillrow(block + DSIZE * i, block[DSIZE * i]);
173 for (i = 0; i < DSIZE; i++, ptr += DSIZE) {
174 z10 = ptr[0] + ptr[4];
175 z11 = ptr[0] - ptr[4];
176 z13 = ptr[2] + ptr[6];
177 z12 = MULS(ptr[2] - ptr[6], FIX_1_414213562) - z13;
184 z13 = ptr[3] + ptr[5];
185 z10 = ptr[3] - ptr[5];
186 z11 = ptr[1] + ptr[7];
187 z12 = ptr[1] - ptr[7];
190 z5 = (z12 - z10) * FIX_1_847759065;
191 tmp6 = SCALE(z10 * FIX_2_613125930 + z5, AAN_CONST_BITS) - tmp7;
192 tmp5 = MULS(z11 - z13, FIX_1_414213562) - tmp6;
193 tmp4 = SCALE(z12 * FIX_1_082392200 - z5, AAN_CONST_BITS) + tmp5;
195 ptr[0] = tmp0 + tmp7;
197 ptr[7] = tmp0 - tmp7;
198 ptr[1] = tmp1 + tmp6;
199 ptr[6] = tmp1 - tmp6;
200 ptr[2] = tmp2 + tmp5;
201 ptr[5] = tmp2 - tmp5;
202 ptr[4] = tmp3 + tmp4;
203 ptr[3] = tmp3 - tmp4;
208 // mdec0: command register
209 #define MDEC0_STP 0x02000000
210 #define MDEC0_RGB24 0x08000000
211 #define MDEC0_SIZE_MASK 0x0000FFFF
213 // mdec1: status register
214 #define MDEC1_BUSY 0x20000000
215 #define MDEC1_DREQ 0x18000000
216 #define MDEC1_FIFO 0xc0000000
217 #define MDEC1_RGB24 0x02000000
218 #define MDEC1_STP 0x00800000
219 #define MDEC1_RESET 0x80000000
221 struct _pending_dma1 {
232 u8 * block_buffer_pos;
233 u8 block_buffer[16*16*3];
234 struct _pending_dma1 pending_dma1;
237 static int iq_y[DSIZE2], iq_uv[DSIZE2];
239 static int zscan[DSIZE2] = {
240 0 , 1 , 8 , 16, 9 , 2 , 3 , 10,
241 17, 24, 32, 25, 18, 11, 4 , 5 ,
242 12, 19, 26, 33, 40, 48, 41, 34,
243 27, 20, 13, 6 , 7 , 14, 21, 28,
244 35, 42, 49, 56, 57, 50, 43, 36,
245 29, 22, 15, 23, 30, 37, 44, 51,
246 58, 59, 52, 45, 38, 31, 39, 46,
247 53, 60, 61, 54, 47, 55, 62, 63
250 static int aanscales[DSIZE2] = {
251 1048576, 1454417, 1370031, 1232995, 1048576, 823861, 567485, 289301,
252 1454417, 2017334, 1900287, 1710213, 1454417, 1142728, 787125, 401273,
253 1370031, 1900287, 1790031, 1610986, 1370031, 1076426, 741455, 377991,
254 1232995, 1710213, 1610986, 1449849, 1232995, 968758, 667292, 340183,
255 1048576, 1454417, 1370031, 1232995, 1048576, 823861, 567485, 289301,
256 823861, 1142728, 1076426, 968758, 823861, 647303, 445870, 227303,
257 567485, 787125, 741455, 667292, 567485, 445870, 307121, 156569,
258 289301, 401273, 377991, 340183, 289301, 227303, 156569, 79818
261 static void iqtab_init(int *iqtab, unsigned char *iq_y) {
264 for (i = 0; i < DSIZE2; i++) {
265 iqtab[i] = (iq_y[i] * SCALER(aanscales[zscan[i]], AAN_PRESCALE_SCALE));
269 #define MDEC_END_OF_DATA 0xfe00
271 static unsigned short *rl2blk(int *blk, unsigned short *mdec_rl) {
272 int i, k, q_scale, rl, used_col;
275 memset(blk, 0, 6 * DSIZE2 * sizeof(int));
277 for (i = 0; i < 6; i++) {
278 // decode blocks (Cr,Cb,Y1,Y2,Y3,Y4)
279 if (i == 2) iqtab = iq_y;
281 rl = SWAP16(*mdec_rl); mdec_rl++;
282 q_scale = RLE_RUN(rl);
283 blk[0] = SCALER(iqtab[0] * RLE_VAL(rl), AAN_EXTRA - 3);
284 for (k = 0, used_col = 0;;) {
285 rl = SWAP16(*mdec_rl); mdec_rl++;
286 if (rl == MDEC_END_OF_DATA) break;
287 k += RLE_RUN(rl) + 1; // skip zero-coefficients
290 // printf("run lenght exceeded 64 enties\n");
294 // zigzag transformation
295 blk[zscan[k]] = SCALER(RLE_VAL(rl) * iqtab[k] * q_scale, AAN_EXTRA);
296 // keep track of used columns to speed up the idtc
297 used_col |= (zscan[k] > 7) ? 1 << (zscan[k] & 7) : 0;
300 if (k == 0) used_col = -1;
301 // used_col is -1 for blocks with only the DC coefficient
302 // any other value is a bitmask of the columns that have
303 // at least one non zero cofficient in the rows 1-7
304 // single coefficients in row 0 are treted specially
305 // in the idtc function
313 // Y/Cb/Cr[0...255] -> R/G/B[0...255]
314 // R = 1.000 * (Y) + 1.400 * (Cr - 128)
315 // G = 1.000 * (Y) - 0.343 * (Cb - 128) - 0.711 (Cr - 128)
316 // B = 1.000 * (Y) + 1.765 * (Cb - 128)
317 #define MULR(a) ((1434 * (a)))
318 #define MULB(a) ((1807 * (a)))
319 #define MULG2(a, b) ((-351 * (a) - 728 * (b)))
320 #define MULY(a) ((a) << 10)
322 #define MAKERGB15(r, g, b, a) (SWAP16(a | ((b) << 10) | ((g) << 5) | (r)))
323 #define SCALE8(c) SCALER(c, 20)
324 #define SCALE5(c) SCALER(c, 23)
326 #define CLAMP5(c) ( ((c) < -16) ? 0 : (((c) > (31 - 16)) ? 31 : ((c) + 16)) )
327 #define CLAMP8(c) ( ((c) < -128) ? 0 : (((c) > (255 - 128)) ? 255 : ((c) + 128)) )
329 #define CLAMP_SCALE8(a) (CLAMP8(SCALE8(a)))
330 #define CLAMP_SCALE5(a) (CLAMP5(SCALE5(a)))
332 static inline void putlinebw15(u16 *image, int *Yblk) {
334 int A = (mdec.reg0 & MDEC0_STP) ? 0x8000 : 0;
336 for (i = 0; i < 8; i++, Yblk++) {
339 image[i] = SWAP16((CLAMP5(Y >> 3) * 0x421) | A);
343 static inline void putquadrgb15(u16 *image, int *Yblk, int Cr, int Cb) {
345 int A = (mdec.reg0 & MDEC0_STP) ? 0x8000 : 0;
350 // added transparency
352 image[0] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
354 image[1] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
356 image[16] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
358 image[17] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
361 static inline void yuv2rgb15(int *blk, unsigned short *image) {
363 int *Yblk = blk + DSIZE2 * 2;
365 int *Cbblk = blk + DSIZE2;
368 for (y = 0; y < 16; y += 2, Crblk += 4, Cbblk += 4, Yblk += 8, image += 24) {
369 if (y == 8) Yblk += DSIZE2;
370 for (x = 0; x < 4; x++, image += 2, Crblk++, Cbblk++, Yblk += 2) {
371 putquadrgb15(image, Yblk, *Crblk, *Cbblk);
372 putquadrgb15(image + 8, Yblk + DSIZE2, *(Crblk + 4), *(Cbblk + 4));
376 for (y = 0; y < 16; y++, Yblk += 8, image += 16) {
377 if (y == 8) Yblk += DSIZE2;
378 putlinebw15(image, Yblk);
379 putlinebw15(image + 8, Yblk + DSIZE2);
384 static inline void putlinebw24(u8 * image, int *Yblk) {
387 for (i = 0; i < 8 * 3; i += 3, Yblk++) {
395 static inline void putquadrgb24(u8 * image, int *Yblk, int Cr, int Cb) {
403 image[0 * 3 + 0] = CLAMP_SCALE8(Y + R);
404 image[0 * 3 + 1] = CLAMP_SCALE8(Y + G);
405 image[0 * 3 + 2] = CLAMP_SCALE8(Y + B);
407 image[1 * 3 + 0] = CLAMP_SCALE8(Y + R);
408 image[1 * 3 + 1] = CLAMP_SCALE8(Y + G);
409 image[1 * 3 + 2] = CLAMP_SCALE8(Y + B);
411 image[16 * 3 + 0] = CLAMP_SCALE8(Y + R);
412 image[16 * 3 + 1] = CLAMP_SCALE8(Y + G);
413 image[16 * 3 + 2] = CLAMP_SCALE8(Y + B);
415 image[17 * 3 + 0] = CLAMP_SCALE8(Y + R);
416 image[17 * 3 + 1] = CLAMP_SCALE8(Y + G);
417 image[17 * 3 + 2] = CLAMP_SCALE8(Y + B);
420 static void yuv2rgb24(int *blk, u8 *image) {
422 int *Yblk = blk + DSIZE2 * 2;
424 int *Cbblk = blk + DSIZE2;
427 for (y = 0; y < 16; y += 2, Crblk += 4, Cbblk += 4, Yblk += 8, image += 8 * 3 * 3) {
428 if (y == 8) Yblk += DSIZE2;
429 for (x = 0; x < 4; x++, image += 6, Crblk++, Cbblk++, Yblk += 2) {
430 putquadrgb24(image, Yblk, *Crblk, *Cbblk);
431 putquadrgb24(image + 8 * 3, Yblk + DSIZE2, *(Crblk + 4), *(Cbblk + 4));
435 for (y = 0; y < 16; y++, Yblk += 8, image += 16 * 3) {
436 if (y == 8) Yblk += DSIZE2;
437 putlinebw24(image, Yblk);
438 putlinebw24(image + 8 * 3, Yblk + DSIZE2);
443 void mdecInit(void) {
444 memset(&mdec, 0, sizeof(mdec));
445 memset(iq_y, 0, sizeof(iq_y));
446 memset(iq_uv, 0, sizeof(iq_uv));
447 mdec.rl = (u16 *)&psxM[0x100000];
451 void mdecWrite0(u32 data) {
455 u32 mdecRead0(void) {
460 void mdecWrite1(u32 data) {
461 if (data & MDEC1_RESET) { // mdec reset
464 mdec.pending_dma1.adr = 0;
465 mdec.block_buffer_pos = 0;
469 u32 mdecRead1(void) {
474 void psxDma0(u32 adr, u32 bcr, u32 chcr) {
478 if (chcr != 0x01000201) {
479 log_unhandled("mdec0: invalid dma %08x\n", chcr);
483 /* mdec is STP till dma0 is released */
484 mdec.reg1 |= MDEC1_STP;
486 size = (bcr >> 16) * (bcr & 0xffff);
489 case 0x3: // decode 15/24bpp
490 mdec.rl = (u16 *) PSXM(adr);
491 /* now the mdec is busy till all data are decoded */
492 mdec.reg1 |= MDEC1_BUSY;
493 /* detect the end of decoding */
494 mdec.rl_end = mdec.rl + (size * 2);
497 if(mdec.rl_end <= mdec.rl)
500 /* process the pending dma1 */
501 if(mdec.pending_dma1.adr){
502 psxDma1(mdec.pending_dma1.adr, mdec.pending_dma1.bcr, mdec.pending_dma1.chcr);
504 mdec.pending_dma1.adr = 0;
508 case 0x4: // quantization table upload
510 u8 *p = (u8 *)PSXM(adr);
511 // printf("uploading new quantization table\n");
513 // printmatrixu8(p + 64);
515 iqtab_init(iq_uv, p + 64);
519 case 0x6: // cosine table
520 // printf("mdec cosine table\n");
524 log_unhandled("mdec: unknown command %08x\n", cmd);
531 void mdec0Interrupt()
533 if (HW_DMA0_CHCR & SWAP32(0x01000000))
535 HW_DMA0_CHCR &= SWAP32(~0x01000000);
540 #define SIZE_OF_24B_BLOCK (16*16*3)
541 #define SIZE_OF_16B_BLOCK (16*16*2)
543 void psxDma1(u32 adr, u32 bcr, u32 chcr) {
549 if (chcr != 0x01000200) {
550 log_unhandled("mdec1: invalid dma %08x\n", chcr);
554 words = (bcr >> 16) * (bcr & 0xffff);
558 if (!(mdec.reg1 & MDEC1_BUSY)) {
560 mdec.pending_dma1.adr = adr;
561 mdec.pending_dma1.bcr = bcr;
562 mdec.pending_dma1.chcr = chcr;
563 /* do not free the dma */
566 image = (u8 *)PSXM(adr);
568 if (mdec.reg0 & MDEC0_RGB24) {
570 * block are 16 px * 16 px, each px are 2 byte
573 /* there is some partial block pending ? */
574 if(mdec.block_buffer_pos != 0) {
575 int n = mdec.block_buffer - mdec.block_buffer_pos + SIZE_OF_16B_BLOCK;
576 /* TODO: check if partial block do not larger than size */
577 memcpy(image, mdec.block_buffer_pos, n);
580 mdec.block_buffer_pos = 0;
583 while(size >= SIZE_OF_16B_BLOCK) {
584 mdec.rl = rl2blk(blk, mdec.rl);
585 yuv2rgb15(blk, (u16 *)image);
586 image += SIZE_OF_16B_BLOCK;
587 size -= SIZE_OF_16B_BLOCK;
591 mdec.rl = rl2blk(blk, mdec.rl);
592 yuv2rgb15(blk, (u16 *)mdec.block_buffer);
593 memcpy(image, mdec.block_buffer, size);
594 mdec.block_buffer_pos = mdec.block_buffer + size;
599 * block are 16 px * 16 px, each px are 3 byte
602 /* there is some partial block pending ? */
603 if(mdec.block_buffer_pos != 0) {
604 int n = mdec.block_buffer - mdec.block_buffer_pos + SIZE_OF_24B_BLOCK;
605 /* TODO: check if partial block do not larger than size */
606 memcpy(image, mdec.block_buffer_pos, n);
609 mdec.block_buffer_pos = 0;
612 while(size >= SIZE_OF_24B_BLOCK) {
613 mdec.rl = rl2blk(blk, mdec.rl);
614 yuv2rgb24(blk, image);
615 image += SIZE_OF_24B_BLOCK;
616 size -= SIZE_OF_24B_BLOCK;
620 mdec.rl = rl2blk(blk, mdec.rl);
621 yuv2rgb24(blk, mdec.block_buffer);
622 memcpy(image, mdec.block_buffer, size);
623 mdec.block_buffer_pos = mdec.block_buffer + size;
627 /* define the power of mdec */
628 MDECOUTDMA_INT(words * MDEC_BIAS);
629 /* some CPU stalling */
630 psxRegs.cycle += words;
634 void mdec1Interrupt() {
637 * in that case we have done all decoding stuff
638 * Note that : each block end with 0xfe00 flags
639 * the list of blocks end with the same 0xfe00 flags
655 * if the 0xfe00 is not present the data size is important.
659 /* MDEC_END_OF_DATA avoids read outside memory */
660 if (mdec.rl >= mdec.rl_end || SWAP16(*(mdec.rl)) == MDEC_END_OF_DATA) {
661 mdec.reg1 &= ~(MDEC1_STP|MDEC1_BUSY);
662 if (HW_DMA0_CHCR & SWAP32(0x01000000))
664 HW_DMA0_CHCR &= SWAP32(~0x01000000);
669 if (HW_DMA1_CHCR & SWAP32(0x01000000))
671 HW_DMA1_CHCR &= SWAP32(~0x01000000);
676 int mdecFreeze(void *f, int Mode) {
677 u8 *base = (u8 *)&psxM[0x100000];
680 gzfreeze(&mdec.reg0, sizeof(mdec.reg0));
681 gzfreeze(&mdec.reg1, sizeof(mdec.reg1));
683 // old code used to save raw pointers..
684 v = (u8 *)mdec.rl - base;
685 gzfreeze(&v, sizeof(v));
686 mdec.rl = (u16 *)(base + (v & 0xffffe));
687 v = (u8 *)mdec.rl_end - base;
688 gzfreeze(&v, sizeof(v));
689 mdec.rl_end = (u16 *)(base + (v & 0xffffe));
692 if (mdec.block_buffer_pos)
693 v = mdec.block_buffer_pos - base;
694 gzfreeze(&v, sizeof(v));
695 mdec.block_buffer_pos = 0;
697 mdec.block_buffer_pos = base + (v & 0xfffff);
699 gzfreeze(&mdec.block_buffer, sizeof(mdec.block_buffer));
700 gzfreeze(&mdec.pending_dma1, sizeof(mdec.pending_dma1));
701 gzfreeze(iq_y, sizeof(iq_y));
702 gzfreeze(iq_uv, sizeof(iq_uv));