/[pcsx2_0.9.7]/trunk/pcsx2/IPU/mpeg2lib/Mpeg.cpp
ViewVC logotype

Diff of /trunk/pcsx2/IPU/mpeg2lib/Mpeg.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 62 by william, Tue Sep 7 11:08:22 2010 UTC revision 191 by william, Mon Sep 20 05:35:51 2010 UTC
# Line 47  const int non_linear_quantizer_scale [] Line 47  const int non_linear_quantizer_scale []
47          into 1st slot is copied to the 2nd slot. Which will later be copied          into 1st slot is copied to the 2nd slot. Which will later be copied
48          back to the 1st slot when 128bits have been read.          back to the 1st slot when 128bits have been read.
49  */  */
 extern void ReorderBitstream();  
50  const DCTtab * tab;  const DCTtab * tab;
51  int mbaCount = 0;  int mbaCount = 0;
52    
53    int bitstream_init ()
54    {
55            return g_BP.FillBuffer(32);
56    }
57    
58  int get_macroblock_modes()  int get_macroblock_modes()
59  {  {
60          int macroblock_modes;          int macroblock_modes;
# Line 221  int __fi get_motion_delta(const int f_co Line 225  int __fi get_motion_delta(const int f_co
225    
226  int __fi get_dmv()  int __fi get_dmv()
227  {  {
228          const DMVtab * tab;          const DMVtab* tab = DMV_2 + UBITS(2);
   
         tab = DMV_2 + UBITS(2);  
229          DUMPBITS(tab->len);          DUMPBITS(tab->len);
230          return tab->dmv;          return tab->dmv;
231  }  }
# Line 239  int get_macroblock_address_increment() Line 241  int get_macroblock_address_increment()
241          else if (code >= 768)          else if (code >= 768)
242                  mba = MBA.mba11 + (UBITS(11) - 24);                  mba = MBA.mba11 + (UBITS(11) - 24);
243          else switch (UBITS(11))          else switch (UBITS(11))
244                  {          {
245                    case 8:         /* macroblock_escape */
246                            DUMPBITS(11);
247                            return 0x23;
248    
249                          case 8:         /* macroblock_escape */                  case 15:        /* macroblock_stuffing (MPEG1 only) */
250                            if (decoder.mpeg1)
251                            {
252                                  DUMPBITS(11);                                  DUMPBITS(11);
253                                  return 0x23;                                  return 0x22;
254                            }
                         case 15:        /* macroblock_stuffing (MPEG1 only) */  
                                 if (decoder.mpeg1)  
                                 {  
                                         DUMPBITS(11);  
                                         return 0x22;  
                                 }  
255    
256                          default:                  default:
257                                  return 0;//error                          return 0;//error
258                  }          }
259    
260          DUMPBITS(mba->len);          DUMPBITS(mba->len);
261    
# Line 336  do {                                                   \ Line 337  do {                                                   \
337          val = (((s32)val) >> 31) ^ 2047;                        \          val = (((s32)val) >> 31) ^ 2047;                        \
338  } while (0)  } while (0)
339    
340  static __fi bool get_intra_block()  static bool get_intra_block()
341  {  {
         int i;  
         int j;  
         int val;  
342          const u8 * scan = decoder.scantype ? mpeg2_scan.alt : mpeg2_scan.norm;          const u8 * scan = decoder.scantype ? mpeg2_scan.alt : mpeg2_scan.norm;
343          const u8 (&quant_matrix)[64] = decoder.iq;          const u8 (&quant_matrix)[64] = decoder.iq;
344          int quantizer_scale = decoder.quantizer_scale;          int quantizer_scale = decoder.quantizer_scale;
# Line 348  static __fi bool get_intra_block() Line 346  static __fi bool get_intra_block()
346          u16 code;          u16 code;
347    
348          /* decode AC coefficients */          /* decode AC coefficients */
349    for (i=1 + ipu_cmd.pos[4]; ; i++)    for (int i=1 + ipu_cmd.pos[4]; ; i++)
350    {    {
351            switch (ipu_cmd.pos[5])            switch (ipu_cmd.pos[5])
352            {            {
# Line 427  static __fi bool get_intra_block() Line 425  static __fi bool get_intra_block()
425                          return true;                          return true;
426                  }                  }
427                                    
428                  i+= tab->run == 65 ? GETBITS(6) : tab->run;                  i += (tab->run == 65) ? GETBITS(6) : tab->run;
429                  if (i >= 64)                  if (i >= 64)
430                  {                  {
431                          ipu_cmd.pos[4] = 0;                          ipu_cmd.pos[4] = 0;
432                          return true;                          return true;
433                  }                  }
434    
435            case 1:            case 1:
436                  if (!GETWORD())            {
437                  {                          if (!GETWORD())
438                    ipu_cmd.pos[4] = i - 1;                          {
439                    ipu_cmd.pos[5] = 1;                                  ipu_cmd.pos[4] = i - 1;
440                    return false;                                  ipu_cmd.pos[5] = 1;
441                  }                                  return false;
442                            }
443    
444                  j = scan[i];                          uint j = scan[i];
445                            int val;
446    
447                  if (tab->run==65) /* escape */                          if (tab->run==65) /* escape */
448                  {                          {
449                    if(!decoder.mpeg1)                                  if(!decoder.mpeg1)
450                    {                                  {
451                            val = (SBITS(12) * quantizer_scale * quant_matrix[i]) >> 4;                                    val = (SBITS(12) * quantizer_scale * quant_matrix[i]) >> 4;
452                            DUMPBITS(12);                                    DUMPBITS(12);
453                    }                                  }
454                    else                                  else
455                    {                                  {
456                            val = SBITS(8);                                    val = SBITS(8);
457                            DUMPBITS(8);                                    DUMPBITS(8);
458    
459                            if (!(val & 0x7f))                                    if (!(val & 0x7f))
460                            {                                    {
461                                  val = GETBITS(8) + 2 * val;                                          val = GETBITS(8) + 2 * val;
462                            }                                    }
                           
                           val = (val * quantizer_scale * quant_matrix[i]) >> 4;  
                           val = (val + ~ (((s32)val) >> 31)) | 1;  
                   }  
                 }  
                 else  
                 {  
                   val = (tab->level * quantizer_scale * quant_matrix[i]) >> 4;  
                   if(decoder.mpeg1)  
                   {  
                         /* oddification */  
                         val = (val - 1) | 1;  
                   }  
   
                   /* if (bitstream_get (1)) val = -val; */  
                   val = (val ^ SBITS(1)) - SBITS(1);  
                   DUMPBITS(1);  
                 }  
463    
464                  SATURATE(val);                                    val = (val * quantizer_scale * quant_matrix[i]) >> 4;
465                  dest[j] = val;                                    val = (val + ~ (((s32)val) >> 31)) | 1;
466                  ipu_cmd.pos[5] = 0;                                  }
467                            }
468                            else
469                            {
470                                    val = (tab->level * quantizer_scale * quant_matrix[i]) >> 4;
471                                    if(decoder.mpeg1)
472                                    {
473                                            /* oddification */
474                                            val = (val - 1) | 1;
475                                    }
476    
477                                    /* if (bitstream_get (1)) val = -val; */
478                                    int bit1 = SBITS(1);
479                                    val = (val ^ bit1) - bit1;
480                                    DUMPBITS(1);
481                            }
482    
483                            SATURATE(val);
484                            dest[j] = val;
485                            ipu_cmd.pos[5] = 0;
486                    }
487           }           }
488    }    }
489    
# Line 488  static __fi bool get_intra_block() Line 491  static __fi bool get_intra_block()
491    return true;    return true;
492  }  }
493    
494  static __fi bool get_non_intra_block(int * last)  static bool get_non_intra_block(int * last)
495  {  {
496          int i;          int i;
497          int j;          int j;
# Line 614  static __fi bool get_non_intra_block(int Line 617  static __fi bool get_non_intra_block(int
617                          }                          }
618                          else                          else
619                          {                          {
620                                    int bit1 = SBITS(1);
621                                  val = ((2 * tab->level + 1) * quantizer_scale * quant_matrix[i]) >> 5;                                  val = ((2 * tab->level + 1) * quantizer_scale * quant_matrix[i]) >> 5;
622                                  val = (val ^ SBITS(1)) - SBITS(1);                                  val = (val ^ bit1) - bit1;
623                                  DUMPBITS(1);                                  DUMPBITS(1);
624                          }                          }
625    
# Line 682  void __fi finishmpeg2sliceIDEC() Line 686  void __fi finishmpeg2sliceIDEC()
686  {  {
687          ipuRegs.ctrl.SCD = 0;          ipuRegs.ctrl.SCD = 0;
688          coded_block_pattern = decoder.coded_block_pattern;          coded_block_pattern = decoder.coded_block_pattern;
   
         g_BP.BP += decoder.bitstream_bits - 16;  
   
         if ((int)g_BP.BP < 0)  
         {  
                 g_BP.BP = 128 + (int)g_BP.BP;  
   
                 // After BP is positioned correctly, we need to reload the old buffer  
                 // so that reading may continue properly  
                 ReorderBitstream();  
         }  
   
         FillInternalBuffer(&g_BP.BP, 1, 0);  
689  }  }
690    
691  bool mpeg2sliceIDEC()  bool mpeg2sliceIDEC()
692  {  {
693          u16 code;          u16 code;
         u8 bit8;  
694    
695          switch (ipu_cmd.pos[0])          switch (ipu_cmd.pos[0])
696          {          {
# Line 798  bool mpeg2sliceIDEC() Line 788  bool mpeg2sliceIDEC()
788                                                  ipu_cmd.pos[2] = 6;                                                  ipu_cmd.pos[2] = 6;
789                                                  return false;                                                  return false;
790                                          }                                          }
791                                            break;
792    
793                                    jNO_DEFAULT;
794                                  }                                  }
795    
796                                  // Send The MacroBlock via DmaIpuFrom                                  // Send The MacroBlock via DmaIpuFrom
# Line 812  bool mpeg2sliceIDEC() Line 805  bool mpeg2sliceIDEC()
805                                  }                                  }
806    
807                          case 2:                          case 2:
808                                  while (decoder.ipu0_data > 0)                          {
809                                  {                                  pxAssume(decoder.ipu0_data > 0);
                                         uint read = ipu_fifo.out.write((u32*)decoder.GetIpuDataPtr(), decoder.ipu0_data);  
810    
811                                          if (read == 0)                                  uint read = ipu_fifo.out.write((u32*)decoder.GetIpuDataPtr(), decoder.ipu0_data);
812                                          {                                  decoder.AdvanceIpuDataBy(read);
813                                                  ipu_cmd.pos[1] = 2;  
814                                                  return false;                                  if (decoder.ipu0_data != 0)
815                                          }                                  {
816                                          else                                          // IPU FIFO filled up -- Will have to finish transferring later.
817                                          {                                          ipu_cmd.pos[1] = 2;
818                                                  decoder.AdvanceIpuDataBy(read);                                          return false;
                                         }  
819                                  }                                  }
820    
821                                  decoder.mbc++;                                  decoder.mbc++;
822                                  mbaCount = 0;                                  mbaCount = 0;
823                            }
824                            
825                          case 3:                          case 3:
826                                  while (1)                                  while (1)
827                                  {                                  {
# Line 851  bool mpeg2sliceIDEC() Line 844  bool mpeg2sliceIDEC()
844                                          }                                          }
845                                          else switch (UBITS(11))                                          else switch (UBITS(11))
846                                          {                                          {
847                                                          case 8:         /* macroblock_escape */                                                  case 8:         /* macroblock_escape */
848                                                                  mbaCount += 33;                                                          mbaCount += 33;
849                                                                  /* pass through */                                                          /* pass through */
850    
851                                                          case 15:        /* macroblock_stuffing (MPEG1 only) */                                                  case 15:        /* macroblock_stuffing (MPEG1 only) */
852                                                                  DUMPBITS(11);                                                          DUMPBITS(11);
853                                                                  continue;                                                          continue;
854    
855                                                          default:        /* end of slice/frame, or error? */                                                  default:        /* end of slice/frame, or error? */
856                                                          {                                                  {
857                                                                  goto finish_idec;                                                                goto finish_idec;      
858                                                          }                                                  }
859                                          }                                          }
860                                  }                                  }
861    
# Line 886  bool mpeg2sliceIDEC() Line 879  bool mpeg2sliceIDEC()
879                                  }                                  }
880    
881                                  break;                                  break;
882    
883                            jNO_DEFAULT;
884                          }                          }
885    
886                          ipu_cmd.pos[1] = 0;                          ipu_cmd.pos[1] = 0;
887                          ipu_cmd.pos[2] = 0;                          ipu_cmd.pos[2] = 0;
888                  }                  }
889                    
890  finish_idec:  finish_idec:
891                  finishmpeg2sliceIDEC();                  finishmpeg2sliceIDEC();
892    
893          case 3:          case 3:
894                  bit8 = 1;          {
895                    u8 bit8;
896                  if (!getBits8((u8*)&bit8, 0))                  if (!getBits8((u8*)&bit8, 0))
897                  {                  {
898                          ipu_cmd.pos[0] = 3;                          ipu_cmd.pos[0] = 3;
# Line 905  finish_idec: Line 901  finish_idec:
901    
902                  if (bit8 == 0)                  if (bit8 == 0)
903                  {                  {
904                          if (g_BP.BP & 7) g_BP.BP += 8 - (g_BP.BP & 7);                          g_BP.Align();
   
905                          ipuRegs.ctrl.SCD = 1;                          ipuRegs.ctrl.SCD = 1;
906                  }                  }
907            }
908    
909          case 4:          case 4:
910                  if (!getBits32((u8*)&ipuRegs.top, 0))                  if (!getBits32((u8*)&ipuRegs.top, 0))
# Line 917  finish_idec: Line 913  finish_idec:
913                          return false;                          return false;
914                  }                  }
915    
916                  BigEndian(ipuRegs.top, ipuRegs.top);                  ipuRegs.top = BigEndian(ipuRegs.top);
917                  break;                  break;
918    
919            jNO_DEFAULT;
920          }          }
921    
922          return true;          return true;
# Line 927  finish_idec: Line 925  finish_idec:
925  bool mpeg2_slice()  bool mpeg2_slice()
926  {  {
927          int DCT_offset, DCT_stride;          int DCT_offset, DCT_stride;
         u8 bit8;  
928    
929          macroblock_8& mb8 = decoder.mb8;          macroblock_8& mb8 = decoder.mb8;
930          macroblock_16& mb16 = decoder.mb16;          macroblock_16& mb16 = decoder.mb16;
# Line 1010  bool mpeg2_slice() Line 1007  bool mpeg2_slice()
1007                                          return false;                                          return false;
1008                                  }                                  }
1009                                  break;                                  break;
1010    
1011                            jNO_DEFAULT;
1012                          }                          }
1013    
1014                          ipu_copy(mb8, mb16);                          // Copy macroblock8 to macroblock16 - without sign extension.
1015                            // Manually inlined due to MSVC refusing to inline the SSE-optimized version.
1016                            {
1017                                    const u8        *s = (const u8*)&mb8;
1018                                    u16                     *d = (u16*)&mb16;
1019    
1020                                    //Y  bias       - 16 * 16
1021                                    //Cr bias       - 8 * 8
1022                                    //Cb bias       - 8 * 8
1023    
1024                                    __m128i zeroreg = _mm_setzero_si128();
1025    
1026                                    for (uint i = 0; i < (256+64+64) / 32; ++i)
1027                                    {
1028                                            //*d++ = *s++;
1029                                            __m128i woot1 = _mm_load_si128((__m128i*)s);
1030                                            __m128i woot2 = _mm_load_si128((__m128i*)s+1);
1031                                            _mm_store_si128((__m128i*)d,    _mm_unpacklo_epi8(woot1, zeroreg));
1032                                            _mm_store_si128((__m128i*)d+1,  _mm_unpackhi_epi8(woot1, zeroreg));
1033                                            _mm_store_si128((__m128i*)d+2,  _mm_unpacklo_epi8(woot2, zeroreg));
1034                                            _mm_store_si128((__m128i*)d+3,  _mm_unpackhi_epi8(woot2, zeroreg));
1035                                            s += 32;
1036                                            d += 32;
1037                                    }
1038                            }
1039                  }                  }
1040                  else                  else
1041                  {                  {
# Line 1077  bool mpeg2_slice() Line 1100  bool mpeg2_slice()
1100                                                  }                                                  }
1101                                          }                                          }
1102                                          break;                                          break;
1103    
1104                                    jNO_DEFAULT;
1105                                  }                                  }
1106                          }                          }
1107                  }                  }
# Line 1084  bool mpeg2_slice() Line 1109  bool mpeg2_slice()
1109                  // Send The MacroBlock via DmaIpuFrom                  // Send The MacroBlock via DmaIpuFrom
1110                  ipuRegs.ctrl.SCD = 0;                  ipuRegs.ctrl.SCD = 0;
1111                  coded_block_pattern = decoder.coded_block_pattern;                  coded_block_pattern = decoder.coded_block_pattern;
                 g_BP.BP += (int)decoder.bitstream_bits - 16;  
   
                 // BP goes from 0 to 128, so negative values mean to read old buffer  
                 // so we minus from 128 to get the correct BP  
                 if ((int)g_BP.BP < 0)  
                 {  
                         g_BP.BP = 128 + (int)g_BP.BP;  
   
                         // After BP is positioned correctly, we need to reload the old buffer  
                         // so that reading may continue properly  
                         ReorderBitstream();  
                 }  
1112    
1113                  decoder.mbc = 1;                  decoder.mbc = 1;
1114                  decoder.SetOutputTo(mb16);                  decoder.SetOutputTo(mb16);
1115    
1116          case 3:          case 3:
1117                  while (decoder.ipu0_data > 0)          {
1118                  {                  pxAssume(decoder.ipu0_data > 0);
                         uint size = ipu_fifo.out.write((u32*)decoder.GetIpuDataPtr(), decoder.ipu0_data);  
1119    
1120                          if (size == 0)                  uint read = ipu_fifo.out.write((u32*)decoder.GetIpuDataPtr(), decoder.ipu0_data);
1121                          {                  decoder.AdvanceIpuDataBy(read);
1122                                  ipu_cmd.pos[0] = 3;  
1123                                  return false;                  if (decoder.ipu0_data != 0)
1124                          }                  {
1125                          else                          // IPU FIFO filled up -- Will have to finish transferring later.
1126                          {                          ipu_cmd.pos[0] = 3;
1127                                  decoder.AdvanceIpuDataBy(size);                          return false;
                         }  
1128                  }                  }
1129    
1130                    decoder.mbc++;
1131                    mbaCount = 0;
1132            }
1133            
1134          case 4:          case 4:
1135                  bit8 = 1;          {
1136                    u8 bit8;
1137                  if (!getBits8((u8*)&bit8, 0))                  if (!getBits8((u8*)&bit8, 0))
1138                  {                  {
1139                          ipu_cmd.pos[0] = 4;                          ipu_cmd.pos[0] = 4;
# Line 1126  bool mpeg2_slice() Line 1142  bool mpeg2_slice()
1142    
1143                  if (bit8 == 0)                  if (bit8 == 0)
1144                  {                  {
1145                          if (g_BP.BP & 7) g_BP.BP += 8 - (g_BP.BP & 7);                          g_BP.Align();
   
1146                          ipuRegs.ctrl.SCD = 1;                          ipuRegs.ctrl.SCD = 1;
1147                  }                  }
1148            }
1149            
1150          case 5:          case 5:
1151                  if (!getBits32((u8*)&ipuRegs.top, 0))                  if (!getBits32((u8*)&ipuRegs.top, 0))
1152                  {                  {
# Line 1138  bool mpeg2_slice() Line 1154  bool mpeg2_slice()
1154                          return false;                          return false;
1155                  }                  }
1156    
1157                  BigEndian(ipuRegs.top, ipuRegs.top);                  ipuRegs.top = BigEndian(ipuRegs.top);
                 decoder.bitstream_bits = 0;  
1158                  break;                  break;
1159          }          }
1160    

Legend:
Removed from v.62  
changed lines
  Added in v.191

  ViewVC Help
Powered by ViewVC 1.1.22