Ignore:
Timestamp:
01/05/08 11:40:24 (16 years ago)
Author:
radscorpion
Message:

SV7 demuxing and decoding works.
However there are strange artifacts when seeking in SV7 files.. - TODO

File:
1 edited

Legend:

Unmodified
Added
Removed

  • dsfilters/demux_mpc/src/mpc_file.cpp

    r378 r379  
    77//-----------------------------------------------------------------------------
    88#include "stdafx.h"
    9 
     9#include <math.h>
    1010
    1111
    … …  
    2525        extradata_size = 0;
    2626        extradata = (uint8*)malloc(extradata_max_size);
     27        bits_to_skip = 0;
     28
     29        gain_album_db = 0;
     30        gain_album_peak_db = 0;
     31        gain_title_db = 0;
     32        gain_title_peak_db = 0;
    2733}
    2834
    … …  
    9399                reader->GetPosition(&first_ap_pos, &avail);
    94100
    95                 reader->Seek(seek_table_position);
     101                reader->Seek(seek_table_position/8);
    96102                ret = packet.Load(reader);
    97103                ret = ReadSeekTable(&packet);
    … …  
    126132
    127133        uint8           hdr[8*4];
     134       
     135        __int64 c, a;
     136        reader->GetPosition(&c, &a);
    128137        ret = reader->Read(extradata + 4, 6*4);
    129138        if (ret < 0) return -1;                 // not enough data
    130         memcpy(hdr, extradata+4, 5*4);
    131139        extradata_size += 6*4;
     140        reader->Seek(c);
     141        ret = reader->ReadSwapped(hdr, 6*4);
    132142        Bitstream       b(hdr);
    133143
    134         b.NeedBits32_MPC();
    135         audio_block_frames = (b.UGetBits(16)<<16) | b.UGetBits(16);
    136 
    137         b.NeedBits32_MPC();
     144        b.NeedBits32();
     145        int audio_frames = (b.UGetBits(16)<<16) | b.UGetBits(16);
     146
     147        b.NeedBits32();
    138148        b.UGetBits(1);                          // intensity stereo, should be 0
    139149        b.UGetBits(1);                          // mid-side
    … …  
    153163        b.UGetBits(16);                         // max-level
    154164
    155         b.NeedBits32_MPC();
    156         gain_title_db = b.SGetBits(16) / 100.0;                         // title gain
    157         gain_title_peak_db = b.UGetBits(16);            // title peak
    158 
    159         b.NeedBits32_MPC();
    160         gain_album_db = b.SGetBits(16) / 100.0;                         // album gain
    161         gain_album_peak_db = b.UGetBits(16);            // album peak
    162 
    163 
    164 
    165         b.NeedBits32_MPC();
     165        b.NeedBits32();
     166        gain_title_db = b.SGetBits(16) / 100.0;         // title gain
     167        int title_peak = b.UGetBits(16);
     168        if (title_peak != 0) {
     169                gain_title_peak_db = 20 * log10f((float)title_peak);            // title peak
     170        } else {
     171                gain_title_peak_db = 0;
     172        }
     173
     174        b.NeedBits32();
     175        gain_album_db = b.SGetBits(16) / 100.0;         // album gain
     176        int album_peak = b.UGetBits(16);
     177        if (album_peak != 0) {
     178                gain_album_peak_db = 20 * log10f((float)album_peak);            // album peak
     179        } else {
     180                gain_album_peak_db = 0;
     181        }
     182
     183        #define OLD_GAIN_REF            64.82
     184        if (gain_title_db != 0) {
     185                gain_title_db = OLD_GAIN_REF - gain_title_db;
     186        }
     187        if (gain_album_db != 0) {
     188                gain_album_db = OLD_GAIN_REF - gain_album_db;
     189        }
     190
     191        b.NeedBits32();
    166192        true_gapless = b.UGetBits(1);                   // true gapless
    167193        int last_frame = b.UGetBits(11);                // last-frame samples
    168         total_samples = (audio_block_frames * 1152);
     194        audio_block_frames = 1;
     195        total_samples = (audio_frames * 1152);
    169196        if (true_gapless) {
    170197                total_samples -= (1152 - last_frame);
    … …  
    178205        b.UGetBits(3);
    179206
    180         b.NeedBits32_MPC();
     207        b.NeedBits32();
    181208        int ver = b.UGetBits(8);
    182209
    … …  
    192219
    193220        // alloc memory for seek table
    194         seek_table = (uint32*)malloc(tmp * sizeof(uint32));
     221        seek_table = (uint64*)malloc(tmp * sizeof(uint64));
    195222        if (!seek_table) return -1;
    196223
    197224        int64 pos, av;
    198225        reader->GetPosition(&pos, &av);
    199         seek_table[0] = pos*8;          // current position in bits
     226        seek_table[0] = pos*8 - b.BitsLeft();           // current position in bits
    200227        seek_table_size = 1;
    201228
    202         // TODO: loop through file to get complete seeking table
    203 
     229        // loop through file to get complete seeking table
     230        CMPCPacket      packet;
     231        int64 seek_frames = 0;
     232        Seek(0);
     233        do {
     234                if (seek_frames*1152 >= total_samples) break;
     235
     236                // new entry in seeking table
     237                if (seek_frames == (seek_table_size << seek_pwr)) {
     238                        __int64 c, a;
     239                        reader->GetPosition(&c, &a);
     240                        seek_table[seek_table_size] = (c*8) + bits_to_skip;
     241                        seek_table_size++;
     242                }
     243
     244                ret = packet.Load_SV7(reader, bits_to_skip, true);
     245                if (ret<0) break;
     246                seek_frames += 1;
     247        } while (true);
     248
     249        // seek to begin
     250        Seek(0);
     251
     252        header_position = 0;
     253        bits_to_skip = 0;
    204254        return 0;
    205255}
    … …  
    261311        Bitstream       b(packet->payload);
    262312
    263         seek_table_position = b.GetMpcSize();
     313        seek_table_position = b.GetMpcSize() * 8;
    264314        seek_table_position += packet->file_position;
    265315
    … …  
    280330
    281331        // alloc memory for seek table
    282         seek_table = (uint32*)malloc(tmp * sizeof(uint32));
    283 
    284         uint32 *table = seek_table;
     332        seek_table = (uint64*)malloc(tmp * sizeof(uint64));
     333
     334        uint64 *table = seek_table;
    285335
    286336        tmp = b.GetMpcSize();
    287         table[0] = (uint32)(tmp + header_position) * 8;
     337        table[0] = (uint32)(tmp*8 + header_position);
    288338        if (seek_table_size == 1) return 0;
    289339
    290340        tmp = b.GetMpcSize();
    291         table[1] = (uint32)(tmp + header_position) * 8;
     341        table[1] = (uint64)(tmp*8 + header_position);
    292342        for (int i=2; i<seek_table_size; i++) {
    293343                int code = b.Get_Golomb(12);
    … …  
    316366
    317367        switch (stream_version) {
    318         case 7:
    319                 {
    320                         //-----------------------------------------------------------------
    321                         //      Stream Version 7
    322                         //-----------------------------------------------------------------
    323 
    324                         // since we don't do any actual decoding here, we can only look
    325                         // for the fields of our interest
    326 
    327                         // TODO: later. now we want SV8
    328 
    329                 }
    330                 break;
    331368        case 8:
    332369                {
    … …  
    361398
    362399                        // store absolute position of stream header
    363                         header_position = packet->file_position -4;
     400                        header_position = packet->file_position - 4*8;
    364401                }
    365402                break;
    … …  
    379416        int ret;
    380417
     418        // end of file ?
     419        if (current_sample >= total_samples) return -2;
     420
    381421        do {
    382                 ret = packet->Load(reader);
     422                switch (stream_version) {
     423                case 7: ret = packet->Load_SV7(reader, bits_to_skip); break;
     424                case 8: ret = packet->Load(reader); break;
     425                default: ret = -2; break;
     426                }
    383427                if (ret < 0) {
    384428                        return ret;
    385429                }
    386430
    387                 switch (packet->key) {
    388                 case MPC_KEY('A','P'): 
    389                         {
    390                                 // keep track of samples...
    391                                 if (cur_sample) *cur_sample = current_sample;
    392                                 current_sample += (1152*audio_block_frames);
    393 
    394                                 return 0;                       // we got one
     431                // keep track of samples...
     432                if (cur_sample) *cur_sample = current_sample;
     433                if (stream_version == 8) {
     434                        switch (packet->key) {
     435                        case MPC_KEY('A','P'): 
     436                                {
     437                                        current_sample += (1152*audio_block_frames);
     438                                        return 0;                       // we got one
     439                                }
     440                        case MPC_KEY('S','E'):
     441                                {
     442                                        return -2;
     443                                }
     444                                break;
    395445                        }
    396                 case MPC_KEY('S','E'):
    397                         {
    398                                 return -2;
    399                         }
    400                         break;
     446                } else {
     447                        current_sample += (1152*audio_block_frames);
     448                        return 0;
    401449                }
    402450
    … …  
    438486
    439487        // seek to position
    440         uint32 pos = seek_table[i] >> 3;
    441         CString f;
    442         f.Format(_T("CMPCFile::Seek : %d"), pos);
     488        uint64 pos = seek_table[i] >> 3;
     489        bits_to_skip = seek_table[i] & 0x07;
    443490        reader->Seek(pos);
    444491
    … …  
    483530}
    484531
     532int CMPCPacket::Load_SV7(CMPCReader *reader, int &bits_to_skip, bool only_parse)
     533{
     534        uint8   temp[14*1024];
     535        uint8   outtemp[14*1024];
     536        __int64 cur, av;
     537        int             t;
     538        int             total_bits;
     539
     540        Release();
     541
     542        reader->GetPosition(&cur, &av);
     543        int ret = reader->ReadSwapped(temp, min(sizeof(temp), (av-cur)));
     544        if (ret < 0) return 0;
     545
     546        Bitstream       b(temp);
     547        Bitstream       o(outtemp);
     548        b.NeedBits32();
     549
     550        // We load bits from input file and store it into our buffer.
     551        // There they will always start at byte alignment so they can
     552        // be transferred to decoder in a pleasant way.
     553
     554        // skip bits from previous frame
     555        if (bits_to_skip > 0) { b.DumpBits(bits_to_skip); }
     556        file_position = (cur*8) + bits_to_skip;
     557
     558        // 20-bit frame length
     559        b.NeedBits24();
     560        int     frame_len_bits = b.UGetBits(20);
     561        o.PutBits(frame_len_bits, 20);
     562
     563        if (only_parse == false) {
     564                // load data
     565                int left_bits = frame_len_bits;
     566                while (left_bits > 16) {
     567                        b.NeedBits();
     568                        t = b.UGetBits(16);
     569                        o.PutBits(t, 16);
     570                        left_bits -= 16;
     571                }
     572                b.NeedBits();
     573                t = b.UGetBits(left_bits);
     574                o.PutBits(t, left_bits);
     575
     576                // zero-align 32-bit word
     577                total_bits = (20 + frame_len_bits + 31) &~ 31;
     578                int zero_bits = total_bits - frame_len_bits;
     579                o.PutBits(0, zero_bits);
     580                o.WriteBits();
     581        }
     582
     583        // bits to skip in the next frame
     584        __int64 finalpos = file_position + 20 + frame_len_bits;
     585        bits_to_skip = (finalpos & 7);
     586        reader->Seek(finalpos >> 3);
     587
     588        // copy data
     589        if (only_parse == false) {
     590                packet_size  = total_bits >> 3;
     591                payload_size = packet_size;
     592                packet = (uint8*)malloc(packet_size);
     593                payload = packet;                               // pointer to packet payload
     594
     595                // copy data
     596                uint8 *src = outtemp;
     597                uint8 *dst = packet;
     598                int left = packet_size;
     599                while (left > 3) {
     600                        dst[0] = src[3];
     601                        dst[1] = src[2];
     602                        dst[2] = src[1];
     603                        dst[3] = src[0];
     604                        src += 4;
     605                        dst += 4;
     606                        left-= 4;
     607                }
     608        }
     609
     610        return 0;
     611}
     612
    485613int CMPCPacket::Load(CMPCReader *reader)
    486614{
    … …  
    493621
    494622        // end of stream
    495         if (file_position >= avail) {
    496                 return -2;
    497         }
     623        if (file_position >= avail) return -2;
     624        file_position *= 8;
    498625
    499626        ret = reader->GetKey(key_val);                                 
    500         if (ret < 0) {
    501                 return ret;
    502         }
     627        if (ret < 0) return ret;
     628
    503629        ret = reader->GetSizeElm(size_val, size_len);   
    504         if (ret < 0) {
    505                 return ret;
    506         }
     630        if (ret < 0) return ret;
    507631
    508632        // if the key is not valid, quit
    509         if (!reader->KeyValid(key_val)) {
    510                 return -1;
    511         }
     633        if (!reader->KeyValid(key_val)) return -1;
    512634        key = key_val;
    513635
    … …  
    519641
    520642        // roll back the bytes
    521         reader->Seek(file_position);
     643        reader->Seek(file_position/8);
    522644        ret = reader->Read(packet, packet_size);               
    523         if (ret < 0) {
    524                 return ret;
    525         }
    526 
    527         return 0;
    528 }
    529 
    530 
     645        if (ret < 0) return ret;
     646        return 0;
     647}
     648
     649
Note: See TracChangeset for help on using the changeset viewer.