Previous 199869 Revisions Next

r23482 Thursday 6th June, 2013 at 07:07:16 UTC by Fabio Priuli
(MESS) snes: added save states to SPC7110 games (saving of decompressor variables is probably
not really needed unless you save/restore during the decompression itself, but better safe than sorry). nw.

this leaves out only S-DD1 games as SNES games working in MESS but not supporting save states yet...
[src/mess/machine]sns_spc7110.c sns_spc7110.h

trunk/src/mess/machine/sns_spc7110.c
r23481r23482
156156   save_item(NAME(m_dx_offset));
157157   save_item(NAME(m_ex_offset));
158158   save_item(NAME(m_fx_offset));
159   // TODO: save decomp-related items and fix their restore...
160159}
161160
162161void sns_rom_spc7110_device::device_start()
r23481r23482
319318      + map(3, 24) + map(2, 16) + map(1,  8) + map(0,  0);
320319#undef map
321320   }
321   
322   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_decomp_mode);
323   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_decomp_offset);
324   state_save_register_item_pointer(machine, "SNES_SPC7110", 0, 0, m_decomp_buffer, SPC7110_DECOMP_BUFFER_SIZE);
325   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_decomp_buffer_rdoffset);
326   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_decomp_buffer_wroffset);
327   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_decomp_buffer_length);
328
329   for (int i = 0; i < 32; i++)
330   {
331      state_save_register_item(machine, "SNES_SPC7110", 0, i, m_context[i].index);
332      state_save_register_item(machine, "SNES_SPC7110", 0, i, m_context[i].invert);
333   }
334   
335   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m0_val);
336   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m0_in);
337   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m0_span);
338   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m0_out);
339   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m0_inverts);
340   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m0_lps);
341   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m0_in_count);
342
343   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m1_pixelorder);
344   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m1_realorder);
345   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m1_val);
346   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m1_in);
347   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m1_span);
348   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m1_out);
349   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m1_inverts);
350   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m1_lps);
351   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m1_in_count);
352   
353   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m2_pixelorder);
354   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m2_realorder);
355   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m2_bitplanebuffer);
356   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m2_buffer_index);
357   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m2_val);
358   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m2_in);
359   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m2_span);
360   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m2_out0);
361   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m2_out1);
362   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m2_inverts);
363   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m2_lps);
364   state_save_register_item(machine, "SNES_SPC7110", 0, 0, m_m2_in_count);
322365}
323366
324367void SPC7110_Decomp::reset()
r23481r23482
412455}
413456
414457void SPC7110_Decomp::mode0(UINT8 init, UINT8 *ROM, UINT32 len)
415{
416   static UINT8 val, in, span;
417   static INT32 out, inverts, lps, in_count;
418
458{   
419459   if (init == 1)
420460   {
421      out = inverts = lps = 0;
422      span = 0xff;
423      val = dataread(ROM, len);
424      in = dataread(ROM, len);
425      in_count = 8;
461      m_m0_out = m_m0_inverts = m_m0_lps = 0;
462      m_m0_span = 0xff;
463      m_m0_val = dataread(ROM, len);
464      m_m0_in = dataread(ROM, len);
465      m_m0_in_count = 8;
426466      return;
427467   }
428468
r23481r23482
432472      {
433473         //get context
434474         UINT8 mask = (1 << (bit & 3)) - 1;
435         UINT8 con = mask + ((inverts & mask) ^ (lps & mask));
475         UINT8 con = mask + ((m_m0_inverts & mask) ^ (m_m0_lps & mask));
436476         UINT32 prob, mps, flag_lps;
437477         UINT32 shift = 0;
438478         if (bit > 3)
r23481r23482
442482
443483         //get prob and mps
444484         prob = probability(con);
445         mps = (((out >> 15) & 1) ^ m_context[con].invert);
485         mps = (((m_m0_out >> 15) & 1) ^ m_context[con].invert);
446486
447487         //get bit
448         if (val <= span - prob) //mps
488         if (m_m0_val <= m_m0_span - prob) //mps
449489         {
450            span = span - prob;
451            out = (out << 1) + mps;
490            m_m0_span = m_m0_span - prob;
491            m_m0_out = (m_m0_out << 1) + mps;
452492            flag_lps = 0;
453493         }
454494         else //lps
455495         {
456            val = val - (span - (prob - 1));
457            span = prob - 1;
458            out = (out << 1) + 1 - mps;
496            m_m0_val = m_m0_val - (m_m0_span - (prob - 1));
497            m_m0_span = prob - 1;
498            m_m0_out = (m_m0_out << 1) + 1 - mps;
459499            flag_lps = 1;
460500         }
461501
462502         //renormalize
463         while (span < 0x7f)
503         while (m_m0_span < 0x7f)
464504         {
465505            shift++;
466506
467            span = (span << 1) + 1;
468            val = (val << 1) + (in >> 7);
507            m_m0_span = (m_m0_span << 1) + 1;
508            m_m0_val = (m_m0_val << 1) + (m_m0_in >> 7);
469509
470            in <<= 1;
471            if (--in_count == 0)
510            m_m0_in <<= 1;
511            if (--m_m0_in_count == 0)
472512            {
473               in = dataread(ROM, len);
474               in_count = 8;
513               m_m0_in = dataread(ROM, len);
514               m_m0_in_count = 8;
475515            }
476516         }
477517
478518         //update processing info
479         lps = (lps << 1) + flag_lps;
480         inverts = (inverts << 1) + m_context[con].invert;
519         m_m0_lps = (m_m0_lps << 1) + flag_lps;
520         m_m0_inverts = (m_m0_inverts << 1) + m_context[con].invert;
481521
482522         //update context state
483523         if (flag_lps & toggle_invert(con))
r23481r23482
495535      }
496536
497537      //save byte
498      write(out);
538      write(m_m0_out);
499539   }
500540}
501541
502542void SPC7110_Decomp::mode1(UINT8 init, UINT8 *ROM, UINT32 len)
503543{
504   static INT32 pixelorder[4], realorder[4];
505   static UINT8 in, val, span;
506   static INT32 out, inverts, lps, in_count;
507
508544   if (init == 1)
509545   {
510546      for (int i = 0; i < 4; i++)
511547      {
512         pixelorder[i] = i;
548         m_m1_pixelorder[i] = i;
513549      }
514      out = inverts = lps = 0;
515      span = 0xff;
516      val = dataread(ROM, len);
517      in = dataread(ROM, len);
518      in_count = 8;
550      m_m1_out = m_m1_inverts = m_m1_lps = 0;
551      m_m1_span = 0xff;
552      m_m1_val = dataread(ROM, len);
553      m_m1_in = dataread(ROM, len);
554      m_m1_in_count = 8;
519555      return;
520556   }
521557
r23481r23482
525561      for (int pixel = 0; pixel < 8; pixel++)
526562      {
527563         //get first symbol context
528         UINT32 a = ((out >> (1 * 2)) & 3);
529         UINT32 b = ((out >> (7 * 2)) & 3);
530         UINT32 c = ((out >> (8 * 2)) & 3);
564         UINT32 a = ((m_m1_out >> (1 * 2)) & 3);
565         UINT32 b = ((m_m1_out >> (7 * 2)) & 3);
566         UINT32 c = ((m_m1_out >> (8 * 2)) & 3);
531567         UINT32 con = (a == b) ? (b != c) : (b == c) ? 2 : 4 - (a == c);
532568
533569         //update pixel order
534570         UINT32 m, n;
535571         for (m = 0; m < 4; m++)
536572         {
537            if (pixelorder[m] == a)
573            if (m_m1_pixelorder[m] == a)
538574            {
539575               break;
540576            }
541577         }
542578         for (n = m; n > 0; n--)
543579         {
544            pixelorder[n] = pixelorder[n - 1];
580            m_m1_pixelorder[n] = m_m1_pixelorder[n - 1];
545581         }
546         pixelorder[0] = a;
582         m_m1_pixelorder[0] = a;
547583
548584         //calculate the real pixel order
549585         for (m = 0; m < 4; m++)
550586         {
551            realorder[m] = pixelorder[m];
587            m_m1_realorder[m] = m_m1_pixelorder[m];
552588         }
553589
554590         //rotate reference pixel c value to top
555591         for (m = 0; m < 4; m++)
556592         {
557            if (realorder[m] == c)
593            if (m_m1_realorder[m] == c)
558594            {
559595               break;
560596            }
561597         }
562598         for (n = m; n > 0; n--)
563599         {
564            realorder[n] = realorder[n - 1];
600            m_m1_realorder[n] = m_m1_realorder[n - 1];
565601         }
566         realorder[0] = c;
602         m_m1_realorder[0] = c;
567603
568604         //rotate reference pixel b value to top
569605         for (m = 0; m < 4; m++)
570606         {
571            if (realorder[m] == b)
607            if (m_m1_realorder[m] == b)
572608            {
573609               break;
574610            }
575611         }
576612         for (n = m; n > 0; n--)
577613         {
578            realorder[n] = realorder[n - 1];
614            m_m1_realorder[n] = m_m1_realorder[n - 1];
579615         }
580         realorder[0] = b;
616         m_m1_realorder[0] = b;
581617
582618         //rotate reference pixel a value to top
583619         for (m = 0; m < 4; m++)
584620         {
585            if (realorder[m] == a)
621            if (m_m1_realorder[m] == a)
586622            {
587623               break;
588624            }
589625         }
590626         for (n = m; n > 0; n--)
591627         {
592            realorder[n] = realorder[n - 1];
628            m_m1_realorder[n] = m_m1_realorder[n - 1];
593629         }
594         realorder[0] = a;
630         m_m1_realorder[0] = a;
595631
596632         //get 2 symbols
597633         for (int bit = 0; bit < 2; bit++)
r23481r23482
602638
603639            //get symbol
604640            UINT32 flag_lps;
605            if (val <= span - prob) //mps
641            if (m_m1_val <= m_m1_span - prob) //mps
606642            {
607               span = span - prob;
643               m_m1_span = m_m1_span - prob;
608644               flag_lps = 0;
609645            }
610646            else //lps
611647            {
612               val = val - (span - (prob - 1));
613               span = prob - 1;
648               m_m1_val = m_m1_val - (m_m1_span - (prob - 1));
649               m_m1_span = prob - 1;
614650               flag_lps = 1;
615651            }
616652
617653            //renormalize
618            while (span < 0x7f)
654            while (m_m1_span < 0x7f)
619655            {
620656               shift++;
621657
622               span = (span << 1) + 1;
623               val = (val << 1) + (in >> 7);
658               m_m1_span = (m_m1_span << 1) + 1;
659               m_m1_val = (m_m1_val << 1) + (m_m1_in >> 7);
624660
625               in <<= 1;
626               if (--in_count == 0)
661               m_m1_in <<= 1;
662               if (--m_m1_in_count == 0)
627663               {
628                  in = dataread(ROM, len);
629                  in_count = 8;
664                  m_m1_in = dataread(ROM, len);
665                  m_m1_in_count = 8;
630666               }
631667            }
632668
633669            //update processing info
634            lps = (lps << 1) + flag_lps;
635            inverts = (inverts << 1) + m_context[con].invert;
670            m_m1_lps = (m_m1_lps << 1) + flag_lps;
671            m_m1_inverts = (m_m1_inverts << 1) + m_context[con].invert;
636672
637673            //update context state
638674            if (flag_lps & toggle_invert(con))
r23481r23482
649685            }
650686
651687            //get next context
652            con = 5 + (con << 1) + ((lps ^ inverts) & 1);
688            con = 5 + (con << 1) + ((m_m1_lps ^ m_m1_inverts) & 1);
653689         }
654690
655691         //get pixel
656         b = realorder[(lps ^ inverts) & 3];
657         out = (out << 2) + b;
692         b = m_m1_realorder[(m_m1_lps ^ m_m1_inverts) & 3];
693         m_m1_out = (m_m1_out << 2) + b;
658694      }
659695
660696      //turn pixel data into bitplanes
661      data = morton_2x8(out);
697      data = morton_2x8(m_m1_out);
662698      write(data >> 8);
663699      write(data >> 0);
664700   }
r23481r23482
666702
667703void SPC7110_Decomp::mode2(UINT8 init, UINT8 *ROM, UINT32 len)
668704{
669   static INT32 pixelorder[16], realorder[16];
670   static UINT8 bitplanebuffer[16], buffer_index;
671   static UINT8 in, val, span;
672   static INT32 out0, out1, inverts, lps, in_count;
673
674705   if (init == 1)
675706   {
676707      for (int i = 0; i < 16; i++)
677708      {
678         pixelorder[i] = i;
709         m_m2_pixelorder[i] = i;
679710      }
680      buffer_index = 0;
681      out0 = out1 = inverts = lps = 0;
682      span = 0xff;
683      val = dataread(ROM, len);
684      in = dataread(ROM, len);
685      in_count = 8;
711      m_m2_buffer_index = 0;
712      m_m2_out0 = m_m2_out1 = m_m2_inverts = m_m2_lps = 0;
713      m_m2_span = 0xff;
714      m_m2_val = dataread(ROM, len);
715      m_m2_in = dataread(ROM, len);
716      m_m2_in_count = 8;
686717      return;
687718   }
688719
r23481r23482
692723      for (int pixel = 0; pixel < 8; pixel++)
693724      {
694725         //get first symbol context
695         UINT32 a = ((out0 >> (0 * 4)) & 15);
696         UINT32 b = ((out0 >> (7 * 4)) & 15);
697         UINT32 c = ((out1 >> (0 * 4)) & 15);
726         UINT32 a = ((m_m2_out0 >> (0 * 4)) & 15);
727         UINT32 b = ((m_m2_out0 >> (7 * 4)) & 15);
728         UINT32 c = ((m_m2_out1 >> (0 * 4)) & 15);
698729         UINT32 con = 0;
699730         UINT32 refcon = (a == b) ? (b != c) : (b == c) ? 2 : 4 - (a == c);
700731
r23481r23482
702733         UINT32 m, n;
703734         for (m = 0; m < 16; m++)
704735         {
705            if (pixelorder[m] == a)
736            if (m_m2_pixelorder[m] == a)
706737            {
707738               break;
708739            }
709740         }
710741         for (n = m; n >  0; n--)
711742         {
712            pixelorder[n] = pixelorder[n - 1];
743            m_m2_pixelorder[n] = m_m2_pixelorder[n - 1];
713744         }
714         pixelorder[0] = a;
745         m_m2_pixelorder[0] = a;
715746
716747         //calculate the real pixel order
717748         for (m = 0; m < 16; m++)
718749         {
719            realorder[m] = pixelorder[m];
750            m_m2_realorder[m] = m_m2_pixelorder[m];
720751         }
721752
722753         //rotate reference pixel c value to top
723754         for (m = 0; m < 16; m++)
724755         {
725            if (realorder[m] == c)
756            if (m_m2_realorder[m] == c)
726757            {
727758               break;
728759            }
729760         }
730761         for (n = m; n >  0; n--)
731762         {
732            realorder[n] = realorder[n - 1];
763            m_m2_realorder[n] = m_m2_realorder[n - 1];
733764         }
734         realorder[0] = c;
765         m_m2_realorder[0] = c;
735766
736767         //rotate reference pixel b value to top
737768         for (m = 0; m < 16; m++)
738769         {
739            if (realorder[m] == b)
770            if (m_m2_realorder[m] == b)
740771            {
741772               break;
742773            }
743774         }
744775         for (n = m; n >  0; n--)
745776         {
746            realorder[n] = realorder[n - 1];
777            m_m2_realorder[n] = m_m2_realorder[n - 1];
747778         }
748         realorder[0] = b;
779         m_m2_realorder[0] = b;
749780
750781         //rotate reference pixel a value to top
751782         for (m = 0; m < 16; m++)
752783         {
753            if (realorder[m] == a)
784            if (m_m2_realorder[m] == a)
754785            {
755786               break;
756787            }
757788         }
758789         for (n = m; n >  0; n--)
759790         {
760            realorder[n] = realorder[n - 1];
791            m_m2_realorder[n] = m_m2_realorder[n - 1];
761792         }
762         realorder[0] = a;
793         m_m2_realorder[0] = a;
763794
764795         //get 4 symbols
765796         for (int bit = 0; bit < 4; bit++)
r23481r23482
771802
772803            //get symbol
773804            UINT32 flag_lps;
774            if (val <= span - prob) //mps
805            if (m_m2_val <= m_m2_span - prob) //mps
775806            {
776               span = span - prob;
807               m_m2_span = m_m2_span - prob;
777808               flag_lps = 0;
778809            }
779810            else //lps
780811            {
781               val = val - (span - (prob - 1));
782               span = prob - 1;
812               m_m2_val = m_m2_val - (m_m2_span - (prob - 1));
813               m_m2_span = prob - 1;
783814               flag_lps = 1;
784815            }
785816
786817            //renormalize
787818            shift = 0;
788            while (span < 0x7f)
819            while (m_m2_span < 0x7f)
789820            {
790821               shift++;
791822
792               span = (span << 1) + 1;
793               val = (val << 1) + (in >> 7);
823               m_m2_span = (m_m2_span << 1) + 1;
824               m_m2_val = (m_m2_val << 1) + (m_m2_in >> 7);
794825
795               in <<= 1;
796               if (--in_count == 0)
826               m_m2_in <<= 1;
827               if (--m_m2_in_count == 0)
797828               {
798                  in = dataread(ROM, len);
799                  in_count = 8;
829                  m_m2_in = dataread(ROM, len);
830                  m_m2_in_count = 8;
800831               }
801832            }
802833
803834            //update processing info
804            lps = (lps << 1) + flag_lps;
835            m_m2_lps = (m_m2_lps << 1) + flag_lps;
805836            invertbit = m_context[con].invert;
806            inverts = (inverts << 1) + invertbit;
837            m_m2_inverts = (m_m2_inverts << 1) + invertbit;
807838
808839            //update context state
809840            if (flag_lps & toggle_invert(con))
r23481r23482
824855         }
825856
826857         //get pixel
827         b = realorder[(lps ^ inverts) & 0x0f];
828         out1 = (out1 << 4) + ((out0 >> 28) & 0x0f);
829         out0 = (out0 << 4) + b;
858         b = m_m2_realorder[(m_m2_lps ^ m_m2_inverts) & 0x0f];
859         m_m2_out1 = (m_m2_out1 << 4) + ((m_m2_out0 >> 28) & 0x0f);
860         m_m2_out0 = (m_m2_out0 << 4) + b;
830861      }
831862
832863      //convert pixel data into bitplanes
833      data = morton_4x8(out0);
864      data = morton_4x8(m_m2_out0);
834865      write(data >> 24);
835866      write(data >> 16);
836      bitplanebuffer[buffer_index++] = data >> 8;
837      bitplanebuffer[buffer_index++] = data >> 0;
867      m_m2_bitplanebuffer[m_m2_buffer_index++] = data >> 8;
868      m_m2_bitplanebuffer[m_m2_buffer_index++] = data >> 0;
838869
839      if (buffer_index == 16)
870      if (m_m2_buffer_index == 16)
840871      {
841872         for (int i = 0; i < 16; i++)
842873         {
843            write(bitplanebuffer[i]);
874            write(m_m2_bitplanebuffer[i]);
844875         }
845         buffer_index = 0;
876         m_m2_buffer_index = 0;
846877      }
847878   }
848879}
trunk/src/mess/machine/sns_spc7110.h
r23481r23482
3535   void mode1(UINT8 init, UINT8 *ROM, UINT32 len);
3636   void mode2(UINT8 init, UINT8 *ROM, UINT32 len);
3737
38private:
39   
3840   UINT8 dataread(UINT8 *ROM, UINT32 len);
3941   UINT8 probability(UINT32 n);
4042   UINT8 next_lps(UINT32 n);
r23481r23482
4244   UINT8 toggle_invert(UINT32 n);
4345   UINT32 morton_2x8(UINT32 data);
4446   UINT32 morton_4x8(UINT32 data);
45
47   
4648   UINT32 m_decomp_mode;
4749   UINT32 m_decomp_offset;
48
50   
4951   UINT8 *m_decomp_buffer;
5052   UINT32 m_decomp_buffer_rdoffset;
5153   UINT32 m_decomp_buffer_wroffset;
5254   UINT32 m_decomp_buffer_length;
53
55   
5456   struct ContextState
5557   {
5658      UINT8 index;
5759      UINT8 invert;
5860   } m_context[32];
59
61   
6062   UINT32 m_morton16[2][256];
6163   UINT32 m_morton32[4][256];
6264
65   // mode 0 vars
66   UINT8 m_m0_val, m_m0_in, m_m0_span;
67   INT32 m_m0_out, m_m0_inverts, m_m0_lps, m_m0_in_count;
6368
64private:
69   // mode 1 vars
70   INT32 m_m1_pixelorder[4], m_m1_realorder[4];
71   UINT8 m_m1_in, m_m1_val, m_m1_span;
72   INT32 m_m1_out, m_m1_inverts, m_m1_lps, m_m1_in_count;
73
74   // mode 2 vars
75   INT32 m_m2_pixelorder[16], m_m2_realorder[16];
76   UINT8 m_m2_bitplanebuffer[16], m_m2_buffer_index;
77   UINT8 m_m2_in, m_m2_val, m_m2_span;
78   INT32 m_m2_out0, m_m2_out1, m_m2_inverts, m_m2_lps, m_m2_in_count;
79
6580   running_machine& m_machine;
6681   //UINT32 m_rom_size;
6782};

Previous 199869 Revisions Next

© 1997-2024 The MAME Team