systems.cpp

mpeg2编码解码源程序代码

								PCM_Buffer[j] = *(ld->Rdptr+j+1);
								PCM_Buffer[j+1] = *(ld->Rdptr+j);
							}

							if (SRC_Flag)
							Wavefs44(pcm.file, Packet_Length+pcm.delay, PCM_Buffer-pcm.delay);
							else
							{
								fwrite(PCM_Buffer-pcm.delay, Packet_Length+pcm.delay, 1, pcm.file);
								
								if (Norm_Flag)
									for (j=0; j<(Packet_Length>>1); j++)
									{
										volume = ptrPCM_Buffer[j];

										if (Sound_Max < volume)
											Sound_Max = volume; 
										else if (Sound_Max < -volume)
											Sound_Max = -volume;
									}
							}

							pcm.size += Packet_Length+pcm.delay;
							pcm.delay = 0;
						}
					}

					ld->Rdptr += Packet_Length;
				}
				else
					ld->Rdptr += Packet_Length-4;
				break;
			case AUDIO_ELEMENTARY_STREAM_0:
					if(!AUDIO)
					{
						if(code>=SYSTEM_START_CODE)
      {
       
        code = Get_Word();
        ld->Rdptr += code;
      }
      else
      {
		  
        fprintf(stderr,"Unexpected startcode %08x in system layer\n",code);
        exit(1);
      }
      break;
					}
				Packet_Length = Get_Short();
				code = Get_Byte();
				if ((code & 0xc0)==0x80 && (Track_Flag==MPA_Track || !MPA_Flag))
				{
					CH[MPA_Track] = FORMAT_MPA;

					code = Get_Byte();
					Packet_Header_Length = Get_Byte();

					if (code>=0x80)
					{
						code = Get_Byte();

						AudioPTS = (code & 0x0e) << 29;
						AudioPTS |= (Get_Short() & 0xfffe) << 14;
						AudioPTS |= (Get_Short()>>1) & 0x7fff;
						AudioPTS /= 90;

						ld->Rdptr += Packet_Header_Length-5;
					}
					else
						ld->Rdptr += Packet_Header_Length;

					Packet_Length -= Packet_Header_Length+3;

					while (ld->Rdptr >= (ld->Rdbfr + BUFFER_SIZE))
					{
//						int Read = read(ld->Infile, ld->Rdbfr, BUFFER_SIZE);
                   
					//	if (Read < BUFFER_SIZE)
					//		Next_File();

						ld->Rdptr -= BUFFER_SIZE;
					}

					if (!mpa[MPA_Track].rip && Rip_Flag)
					{
						if ((Format_Flag==FORMAT_MPA || !Format_Flag) && (AVI_Flag || D2V_Flag))
						{
							code = Get_Byte();
							code = (code & 0xff)<<8 | Get_Byte();
							i = 0;

							while (code<0xfff0)
							{
								code = (code & 0xff)<<8 | Get_Byte();
								i++;
							}

							sprintf(szBuffer, "%s MPA T%02d DELAY %dms.mpa", 
								szOutput, MPA_Track+1, AudioPTS-VideoPTS);
						

							mpa[MPA_Track].file = fopen(szBuffer, "wb");

							ld->Rdptr -= 2; Packet_Length -= i;

							while (Packet_Length > 0)
							{
								if (Packet_Length+ld->Rdptr > BUFFER_SIZE+ld->Rdbfr)
								{
									fwrite(ld->Rdptr, BUFFER_SIZE+ld->Rdbfr-ld->Rdptr, 1, mpa[MPA_Track].file);
									memcpy(audiodst+offset,ld->Rdptr,BUFFER_SIZE+ld->Rdbfr-ld->Rdptr);
									offset+=BUFFER_SIZE+ld->Rdbfr-ld->Rdptr;
									Packet_Length -= BUFFER_SIZE+ld->Rdbfr-ld->Rdptr;
//									int Read = read(ld->Infile, ld->Rdbfr, BUFFER_SIZE);
									ld->Rdptr = ld->Rdbfr;
								}
								else
								{
									fwrite(ld->Rdptr, Packet_Length, 1, mpa[MPA_Track].file);
									memcpy(audiodst+offset,ld->Rdptr,Packet_Length);
									offset+=Packet_Length;
								
									ld->Rdptr += Packet_Length;
									Packet_Length = 0;
								}
							}

							mpa[MPA_Track].rip = 1;					
						}
						else
							ld->Rdptr += Packet_Length;
					}
					else if (mpa[MPA_Track].rip)
					{
						while (Packet_Length > 0)
						{
							if (Packet_Length+ld->Rdptr > BUFFER_SIZE+ld->Rdbfr)
							{
								fwrite(ld->Rdptr, BUFFER_SIZE+ld->Rdbfr-ld->Rdptr, 1, mpa[MPA_Track].file);
								memcpy(audiodst+offset,ld->Rdptr,BUFFER_SIZE+ld->Rdbfr-ld->Rdptr);
								offset+=BUFFER_SIZE+ld->Rdbfr-ld->Rdptr;
									
								Packet_Length -= BUFFER_SIZE+ld->Rdbfr-ld->Rdptr;
//								int Read = read(ld->Infile, ld->Rdbfr, BUFFER_SIZE);
								ld->Rdptr = ld->Rdbfr;
							}
							else
							{
								fwrite(ld->Rdptr, Packet_Length, 1, mpa[MPA_Track].file);
								memcpy(audiodst+offset,ld->Rdptr,Packet_Length);
								offset+=Packet_Length;
								ld->Rdptr += Packet_Length;
								Packet_Length = 0;
							}
						}
					}
					else
						ld->Rdptr += Packet_Length;
				}
				else
					ld->Rdptr += Packet_Length-1;

				MPA_Track = 0;
				break;
				//////////////////////////////////////


    case VIDEO_ELEMENTARY_STREAM:   
      code = Get_Word();             /* packet_length */
      ld->Rdmax = ld->Rdptr + code;

      code = Get_Byte();

      if((code>>6)==0x02)
      {
        ld->Rdptr++;
        code=Get_Byte();  /* parse PES_header_data_length */
        ld->Rdptr+=code;    /* advance pointer by PES_header_data_length */
        printf("MPEG-2 PES packet\n");
        return;
      }
      else if(code==0xff)
      {
        /* parse MPEG-1 packet header */
        while((code=Get_Byte())== 0xFF)
		{
			if(SEQEND)
				break;
		}
      }
       
      /* stuffing bytes */
      if(code>=0x40)
      {
        if(code>=0x80)
        {
          fprintf(stderr,"Error in packet header\n");
	
	
//          exit(1);
        }
        /* skip STD_buffer_scale */
        ld->Rdptr++;
        code = Get_Byte();
      }

      if(code>=0x30)
      {
        if(code>=0x40)
        {
          fprintf(stderr,"Error in packet header\n");
		
//          exit(1);
        }
        /* skip presentation and decoding time stamps */
        ld->Rdptr += 9;
      }
      else if(code>=0x20)
      {
        /* skip presentation time stamps */
        ld->Rdptr += 4;
      }
      else if(code!=0x0f)
      {
        fprintf(stderr,"Error in packet header\n");
//        exit(1);
      }
      return;
    case ISO_END_CODE: /* end */
      /* simulate a buffer full of sequence end codes */
      l = 0;
      while (l<2048)
      {
        ld->Rdbfr[l++] = SEQUENCE_END_CODE>>24;
        ld->Rdbfr[l++] = SEQUENCE_END_CODE>>16;
        ld->Rdbfr[l++] = SEQUENCE_END_CODE>>8;
        ld->Rdbfr[l++] = SEQUENCE_END_CODE&0xff;
      }
      ld->Rdptr = ld->Rdbfr;
      ld->Rdmax = ld->Rdbfr + 2048;
      return;
    default:
      if(code>=SYSTEM_START_CODE)
      {
        /* skip system headers and non-video packets*/
        code = Get_Word();
        ld->Rdptr += code;
      }
      else
      {
        fprintf(stderr,"Unexpected startcode %08x in system layer\n",code);
//        exit(1);
      }
      break;
    }
	 if(SEQEND)
	 {
		 return;
	 }
  }
}



void Flush_Buffer32()
{
  int Incnt;

  ld->Bfr = 0;

  Incnt = ld->Incnt;
  Incnt -= 32;

  if (System_Stream_Flag && (ld->Rdptr >= ld->Rdmax-4))
  {
    while (Incnt <= 24)
    {
      if (ld->Rdptr >= ld->Rdmax)
        Next_Packet();
      ld->Bfr |= Get_Byte() << (24 - Incnt);
      Incnt += 8;
    }
  }
  else
  {
    while (Incnt <= 24)
    {
      if (ld->Rdptr >= ld->Rdbfr+2048)
        Fill_Buffer();
      ld->Bfr |= *ld->Rdptr++ << (24 - Incnt);
      Incnt += 8;
    }
  }
  ld->Incnt = Incnt;

#ifdef VERIFY 
  ld->Bitcnt += 32;
#endif /* VERIFY */
}

/*
unsigned int Get_Bits32()
{
  unsigned int l;

  l = SHOW_BITS(32);
  Flush_Buffer32();

  return l;
}


int Get_Long()
{
  int i;

  i = Get_Word();
  return (i<<16) | Get_Word();
}*/