Exemplo n.º 1
0
        public MPAInfo(MPAHeader hdr, UInt64 duration)
        {
            ai_ = new AudioInfo();
            ai_.bitRate = MPAHeaderParser.bitrate(hdr);
            ai_.bitsPerSample = 16;
            ai_.channels = (UInt16)(hdr.channelMode < 3 ? 2 : 1);
            ai_.sampleRate = MPAHeaderParser.samplingRate(hdr);
            ai_.layer = (UInt16)(4 - hdr.layer);
            ai_.vbr = false; //todo

            duration_ = duration;

            switch (hdr.version)
            {
                case 3:
                    {
                        mt_ = MediaType.MPEG10; break;
                    }
                case 2:
                    {
                        mt_ = MediaType.MPEG20; break;
                    }
                case 0:
                    {
                        mt_ = MediaType.MPEG25; break;
                    }
            }
        }
Exemplo n.º 2
0
 public bool isEqual(MPAHeader hdr)
 {
     return hdr.valid && valid && hdr.samplingRate == samplingRate && hdr.version == version && hdr.layer == layer;
 }
Exemplo n.º 3
0
 public static UInt16 samplingRate(MPAHeader hdr)
 {
     return MPASr[3 - hdr.version][hdr.samplingRate];
 }
Exemplo n.º 4
0
 public static UInt16 samples(MPAHeader hdr)
 {
     return MPASpf[3 - hdr.version][3 - hdr.layer];
 }
Exemplo n.º 5
0
        public static MPAHeader parse(Bitstream stream)
        {
            MPAHeader hdr = new MPAHeader();
            hdr.valid = false;

            do
            {
                hdr.sync = (UInt16)(stream.read(11));
                hdr.version = (UInt16)(stream.read(2));
                hdr.layer = (UInt16)(stream.read(2));
                hdr.prot = (UInt16)(1 - stream.read(1));
                hdr.bitRate = (UInt16)(stream.read(4));
                hdr.samplingRate = (UInt16)(stream.read(2));
                hdr.padding = (UInt16)(stream.read(1));
                hdr.priv = (UInt16)(stream.read(1));
                hdr.channelMode = (UInt16)(stream.read(2));
                hdr.modeExtension = (UInt16)(stream.read(2));
                hdr.copyright = (UInt16)(stream.read(1));
                hdr.original = (UInt16)(stream.read(1));
                hdr.emphasis = (UInt16)(stream.read(2));

                hdr.valid = (hdr.sync == 0x7FF) && (hdr.bitRate != 0) && (hdr.bitRate != 15)
                    && (hdr.version != 0) && (hdr.layer != 1);

            }
            while (false);

            return hdr;
        }
Exemplo n.º 6
0
        public static MPAHeader parse(byte[] buff, int offset)
        {
            MPAHeader hdr = new MPAHeader();
            hdr.valid = false;

            do
            {
                if (buff == null || buff.Length < 4 + offset)
                {
                    break;
                }

                hdr.sync = (UInt16)((buff[offset + 0] << 3) + (buff[offset + 1] >> 5));
                hdr.version = (UInt16)((buff[offset + 1] >> 3) & 0x03);
                hdr.layer = (UInt16)((buff[offset + 1] >> 1) & 0x03);
                hdr.prot = (UInt16)(1 - (buff[offset + 1] & 0x01));
                hdr.bitRate = (UInt16)((buff[offset + 2] >> 4) & 0x0F);
                hdr.samplingRate = (UInt16)((buff[offset + 2] >> 2) & 0x03);
                hdr.padding = (UInt16)((buff[offset + 2] >> 1) & 0x01);
                hdr.priv = (UInt16)(buff[offset + 2] & 0x01);
                hdr.channelMode = (UInt16)((buff[offset + 3] >> 6) & 0x03);
                hdr.modeExtension = (UInt16)((buff[offset + 3] >> 4) & 0x03);
                hdr.copyright = (UInt16)((buff[offset + 3] >> 3) & 0x01);
                hdr.original = (UInt16)((buff[offset + 3] >> 2) & 0x01);
                hdr.emphasis = (UInt16)(buff[offset + 3] & 0x03);

                hdr.valid = (hdr.sync == 0x7FF) && (hdr.bitRate != 0) && (hdr.bitRate != 15) && (hdr.version != 0) && (hdr.layer != 1);

            }
            while (false);

            return hdr;
        }
Exemplo n.º 7
0
 public static UInt32 mpaPacketSize(MPAHeader hdr)
 {
     return (samples(hdr) * bitrate(hdr) / (8 * (UInt32)samplingRate(hdr))) + hdr.padding;
 }
Exemplo n.º 8
0
        public static UInt32 bitrate(MPAHeader hdr)
        {
            switch (hdr.version)
            {
                case 3:
                    {

                        return MPABr[hdr.bitRate][3 - hdr.layer];
                    }
                default:
                    {
                        return MPABr[hdr.bitRate][3 + (hdr.layer < 3 ? 1 : 0)];
                    }
            }
        }
Exemplo n.º 9
0
        public static int getIndex(MPAHeader hdr)
        {
            if (hdr.version == 2) //MPEG2
            {
                return 4;
            }

            UInt32 bitrate = (UInt32)((MPAHeaderParser.bitrate(hdr) / 1000) / ((hdr.channelMode == 3) ? 1 : 2));

            switch (hdr.samplingRate)
            {
                case 0:
                    {
                        switch (bitrate)
                        {
                            case 32:
                            case 48:
                                return 2;
                            case 56:
                            case 64:
                            case 80:
                                return 0;
                            case 96:
                            case 112:
                            case 128:
                            case 160:
                            case 192:
                                return 1;
                        }
                        Debug.Assert(false);
                    }
                    break;
                case 1:
                    {
                        switch (bitrate)
                        {
                            case 32:
                            case 48:
                                return 2;
                            case 56:
                            case 64:
                            case 80:
                            case 96:
                            case 112:
                            case 128:
                            case 160:
                            case 192:
                                return 0;
                        }
                        Debug.Assert(false);
                    }
                    break;
                case 2:
                    {
                        switch (bitrate)
                        {
                            case 32:
                            case 48:
                                return 3;
                            case 56:
                            case 64:
                            case 80:
                                return 0;
                            case 96:
                            case 112:
                            case 128:
                            case 160:
                            case 192:
                                return 1;
                        }
                        Debug.Assert(false);
                    }
                    break;
                default:
                    {
                        Debug.Assert(false);
                    }
                    break;
            };

            Debug.Assert(false);
            return 0;
        }
Exemplo n.º 10
0
 ///////////////////////////////////////////
 private void checkError(MPAHeader hdr)
 {
     if (hdr.prot > 0)
     {
         strm_.skip(16);
     }
 }
Exemplo n.º 11
0
        public ErrorCode nextSample(int streamId, out ISample sample)
        {
            sample = null;
            MPAHeader hdr = new MPAHeader();
            hdr.valid = false;
            byte[] tmp = new byte[4];
            while (!hdr.valid)
            {
                tmp[0] = tmp[1];
                tmp[1] = tmp[2];
                tmp[2] = tmp[3];

                reader_.read1(tmp, 3);
                hdr = MPAHeaderParser.parse(tmp, 0);
            }

            byte[] buffer = new byte[MPAHeaderParser.mpaPacketSize(hdr)];
            System.Buffer.BlockCopy(tmp, 0, buffer, 0, 4);

            int size = (int)MPAHeaderParser.mpaPacketSize(hdr) - 4;
            reader_.read(buffer, ref size, 4);

            if (size < (int)length_ - 4)
            {
                return ErrorCode.EndOfStream;
            }

            UInt64 start = 100000 * (UInt64)pos_ * samples_ / info_.getAudioInfo().sampleRate;
            UInt64 stop = 100000 * (UInt64)(pos_ + 1) * samples_ / info_.getAudioInfo().sampleRate;
            sample = new Sample(buffer, start, stop, seek_, discontinuous_);
            discontinuous_ = false;
            ++pos_;

            return ErrorCode.Success;
        }