/* * ac3strm_in.c: AC3 Audio strem class members handling scanning and * buffering raw input stream. * * Copyright (C) 2001 Andrew Stevens * Copyright (C) 2000,2001 Brent Byeler for original header-structure * parsing code. * * * This program is free software; you can redistribute it and/or * modify it under the terms of version 2 of the GNU General Public License * as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "config.h" #include #include #include "audiostrm.hpp" #include "interact.hpp" #include "multiplexor.hpp" //#define DEBUG_AC3_HEADERS #define AC3_SYNCWORD 0x0b77 #define AC3_PACKET_SAMPLES 1536 const unsigned int AC3Stream::default_buffer_size = 16*1024; /// table for the available AC3 bitrates static const unsigned int ac3_bitrate_index[32] = { 32,40,48,56,64,80,96,112,128,160,192, 224,256,320,384,448,512,576,640, 0,0,0,0,0,0,0,0,0,0,0,0,0 }; static const unsigned int ac3_frame_size[3][32] = { { 64,80,96,112,128,160,192,224,256,320,384, 448,512,640,768,896,1024, 1152,1280, 0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 69,87,104,121,139,174,208,243,278,348,417, 487,557,696,835,975,1114, 1253,1393, 0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 96,120,144,168,192,240,288,336,384,480,576, 672,768,960,1152,1344, 1536,1728,1920, 0,0,0,0,0,0,0,0,0,0,0,0,0 } }; /// table for the available AC3 frequencies static const unsigned int ac3_frequency[4] = { 48000, 44100, 32000, 0}; AC3Stream::AC3Stream(IBitStream &ibs, Multiplexor &into) : AudioStream( ibs, into ) { } bool AC3Stream::Probe(IBitStream &bs ) { return bs.GetBits(16) == AC3_SYNCWORD; } /************************************************************************* * * Reads initial stream parameters and displays feedback banner to users * @param stream_num AC3 substream ID *************************************************************************/ void AC3Stream::DisplayAc3HeaderInfo() { /* Some stuff to generate frame-header information */ printf( "bsid = %d\n", bs.GetBits(5) ); printf( "bsmode = 0x%1x\n", bs.GetBits(3) ); int acmode = bs.GetBits(3); int nfchans = 0; switch( acmode ) { case 0x0 : nfchans = 2; break; case 0x1 : nfchans = 1; break; case 0x2 : nfchans = 2; break; case 0x3 : case 0x4 : nfchans = 3; break; case 0x5 : case 0x6 : nfchans = 4; break; case 0x7 : nfchans = 5; break; } printf( "acmode = 0x%1x (%d channels)\n", acmode, nfchans ); if( (acmode & 0x1) && (acmode != 1 ) ) printf( "cmixlev = %d\n", bs.GetBits(2) ); if( (acmode & 0x4) ) printf( "smixlev = %d\n", bs.GetBits(2) ); if( acmode == 2 ) printf( "dsurr = %d\n", bs.GetBits(2) ); printf( "lfeon = %d\n", bs.GetBits(1) ); printf( "dialnorm = %02d\n", bs.GetBits(5) ); int compre = bs.GetBits(1); printf( "compre = %d\n", compre ); if( compre ) printf( "compr = %02d\n", bs.GetBits(8) ); int langcode = bs.GetBits(1); printf( "langcode = %d\n", langcode ); if( langcode ) printf( "langcod = 0x%02x\n", bs.GetBits(8) ); int audprodie = bs.GetBits(1); printf( "audprodie = %d\n", audprodie ); if( audprodie ) { printf( "mixlevel = 0x%02x\n", bs.GetBits(5) ); printf( "roomtyp = 0x%02x\n", bs.GetBits(2) ); } if( acmode == 0 ) { printf( "Skipping 1+1 mode parameters\n" ); bs.GetBits(5+1+8+1+8); if( bs.GetBits(1) ) bs.GetBits(7); } printf( "Copyright = %d\n", bs.GetBits(1) ); printf( "Original = %d\n", bs.GetBits(1) ); int timecod1e = bs.GetBits(1); if( timecod1e ) { printf( "timecod1 = 0x%03x\n", bs.GetBits(14) ); } int timecod2e = bs.GetBits(1); if( timecod2e ) { printf( "timecod2 = 0x%03x\n", bs.GetBits(14) ); } int addbsie = bs.GetBits(1); if( addbsie ) { printf( "addbsil = %02x\n", bs.GetBits(6) ); } // FROM This point on we're actually right into the actual audio block printf( "Audio block header...\n" ); printf( "blksw [ch] = %02x\n", bs.GetBits(nfchans) ); printf( "dithflg[ch] = %02x\n", bs.GetBits(nfchans) ); int dynrnge = bs.GetBits(1); printf( "Dynrange = %d\n", bs.GetBits(1) ); if( dynrnge ) { printf( "dynrng = %02x\n", bs.GetBits(8) ); } if( acmode == 0 && bs.GetBits(1) ) { printf( "dynrng2 = %02x\n", bs.GetBits(8) ); } int cplstre = bs.GetBits(1); printf( "cplstre = %d\n", cplstre ); int cplinu = 0; if( cplstre ) { cplinu = bs.GetBits(1); printf( "cplinu = %d\n", cplinu ); if( cplinu ) { printf( "Skipping cplinu=1 info...\n"); bs.GetBits(nfchans); if( acmode == 2 ) bs.GetBits(1); int cplbegf = bs.GetBits(4); int cplendf = bs.GetBits(4); bs.GetBits(3+cplbegf-cplendf); } } if( cplinu ) { printf( "Warning: no parser for coupling co-ordinates mess\n"); return; } if( acmode == 2 ) { int rmatstr = bs.GetBits(1); printf( "rmatstr = %d\n", rmatstr ); printf( "Warning: no parser for rematrixing...\n" ); } } void AC3Stream::Init ( const int _stream_num) { unsigned int framesize_code; stream_num = _stream_num; MuxStream::Init( PRIVATE_STR_1, 1, // Buffer scale default_buffer_size, false, muxinto.buffers_in_audio, muxinto.always_buffers_in_audio ); mjpeg_info ("Scanning for header info: AC3 Audio stream %02x (%s)", stream_num, bs.StreamName() ); InitAUbuffer(); AU_start = bs.bitcount(); if (bs.GetBits(16)==AC3_SYNCWORD) { num_syncword++; bs.GetBits(16); // CRC field frequency = bs.GetBits(2); // Sample rate code framesize_code = bs.GetBits(6); // Frame size code framesize = ac3_frame_size[frequency][framesize_code>>1]; framesize = (framesize_code&1) && frequency == 1 ? (framesize + 1) << 1: (framesize <<1); header_skip = 5; // Initially skipped past 5 bytes of header num_frames++; access_unit.start = AU_start; access_unit.length = framesize; mjpeg_info( "AC3 frame size = %d\n", framesize ); bit_rate = ac3_bitrate_index[framesize_code>>1]; samples_per_second = ac3_frequency[frequency]; /* Presentation time-stamping */ access_unit.PTS = static_cast(decoding_order) * static_cast(AC3_PACKET_SAMPLES) * static_cast(CLOCKS) / samples_per_second; access_unit.DTS = access_unit.PTS; access_unit.dorder = decoding_order; ++decoding_order; aunits.append( access_unit ); } else { mjpeg_error ( "Invalid AC3 Audio stream header."); exit (1); } OutputHdrInfo(); } /// @returns the current bitrate unsigned int AC3Stream::NominalBitRate() { return bit_rate*1024; } /// Prefills the internal buffer for output multiplexing. /// @param frames_to_buffer the number of audio frames to read ahead void AC3Stream::FillAUbuffer(unsigned int frames_to_buffer ) { unsigned int framesize_code; last_buffered_AU += frames_to_buffer; mjpeg_debug( "Scanning %d AC3 audio frames to frame %d", frames_to_buffer, last_buffered_AU ); int skip; while( !bs.eos() && decoding_order < last_buffered_AU && !muxinto.AfterMaxPTS(access_unit.PTS) ) { skip=access_unit.length-header_skip; bs.SeekFwdBits(skip); prev_offset = AU_start; AU_start = bs.bitcount(); if( AU_start - prev_offset != access_unit.length*8 ) { mjpeg_warn( "Discarding incomplete final frame AC3 stream %d!", stream_num); aunits.droplast(); --decoding_order; break; } /* Check we have reached the end of have another catenated stream to process before finishing ... */ if ( (syncword = bs.GetBits(16))!=AC3_SYNCWORD ) { if( !bs.eos() ) { mjpeg_error_exit1( "Can't find next AC3 frame: @ %lld we have %04x - broken bit-stream?", AU_start/8, syncword ); } break; } bs.GetBits(16); // CRC field bs.GetBits(2); // Sample rate code TOOD: check for change! framesize_code = bs.GetBits(6); framesize = ac3_frame_size[frequency][framesize_code>>1]; framesize = (framesize_code&1) && frequency == 1 ? (framesize + 1) << 1: (framesize <<1); access_unit.start = AU_start; access_unit.length = framesize; access_unit.PTS = static_cast(decoding_order) * static_cast(AC3_PACKET_SAMPLES) * static_cast(CLOCKS) / samples_per_second;; access_unit.DTS = access_unit.PTS; access_unit.dorder = decoding_order; decoding_order++; aunits.append( access_unit ); num_frames++; num_syncword++; if (num_syncword >= old_frames+10 ) { mjpeg_debug ("Got %d frame headers.", num_syncword); old_frames=num_syncword; } } last_buffered_AU = decoding_order; eoscan = bs.eos() || muxinto.AfterMaxPTS(access_unit.PTS); } /// Closes the AC3 stream and prints some statistics. void AC3Stream::Close() { stream_length = AU_start >> 3; mjpeg_info ("AUDIO_STATISTICS: %02x", stream_id); mjpeg_info ("Audio stream length %lld bytes.", stream_length); mjpeg_info ("Frames : %8u", num_frames); } /************************************************************************* OutputAudioInfo gibt gesammelte Informationen zu den Audio Access Units aus. Prints information on audio access units *************************************************************************/ void AC3Stream::OutputHdrInfo () { mjpeg_info("AC3 AUDIO STREAM:"); mjpeg_info ("Bit rate : %8u bytes/sec (%3u kbit/sec)", bit_rate*128, bit_rate); if (frequency == 3) mjpeg_info ("Frequency : reserved"); else mjpeg_info ("Frequency : %d Hz", ac3_frequency[frequency]); } /** Reads the bytes neccessary to complete the current packet payload. @param to_read number of bytes to read @param dst byte buffer pointer to read to @returns the number of bytes read */ unsigned int AC3Stream::ReadPacketPayload(uint8_t *dst, unsigned int to_read) { bitcount_t read_start = bs.GetBytePos(); // Remember to change StreamHeaderLen if you write a different // length re-using this code... unsigned int bytes_read = bs.GetBytes( dst+4, to_read-4 ); assert( bytes_read > 0 ); // Should never try to read nothing bs.Flush( read_start ); clockticks decode_time; unsigned int first_header = (new_au_next_sec || au_unsent > bytes_read ) ? 0 : au_unsent; // BUG BUG BUG: how do we set the 1st header pointer if we have // the *middle* part of a large frame? assert( first_header+2 <= to_read ); unsigned int syncwords = 0; unsigned int bytes_muxed = bytes_read; if (bytes_muxed == 0 || MuxCompleted() ) { goto completion; } /* Work through what's left of the current AU and the following AU's updating the info until we reach a point where an AU had to be split between packets. NOTE: It *is* possible for this loop to iterate. The DTS/PTS field for the packet in this case would have been given the that for the first AU to start in the packet. */ decode_time = RequiredDTS(); while (au_unsent < bytes_muxed) { // BUG BUG BUG: if we ever had odd payload / packet size we might // split an AC3 frame in the middle of the syncword! assert( bytes_muxed > 1 ); bufmodel.Queued(au_unsent, decode_time); bytes_muxed -= au_unsent; if( new_au_next_sec ) ++syncwords; if( !NextAU() ) { goto completion; } new_au_next_sec = true; decode_time = RequiredDTS(); }; // We've now reached a point where the current AU overran or // fitted exactly. We need to distinguish the latter case // so we can record whether the next packet starts with an // existing AU or not - info we need to decide what PTS/DTS // info to write at the start of the next packet. if (au_unsent > bytes_muxed) { if( new_au_next_sec ) ++syncwords; bufmodel.Queued( bytes_muxed, decode_time); au_unsent -= bytes_muxed; new_au_next_sec = false; } else // if (au_unsent == bytes_muxed) { bufmodel.Queued(bytes_muxed, decode_time); if( new_au_next_sec ) ++syncwords; new_au_next_sec = NextAU(); } completion: // Generate the AC3 header... // Note the index counts from the low byte of the offset so // the smallest value is 1! dst[0] = AC3_SUB_STR_0 + stream_num; dst[1] = syncwords; dst[2] = (first_header+1)>>8; dst[3] = (first_header+1)&0xff; return bytes_read+4; } /* * Local variables: * c-file-style: "stroustrup" * tab-width: 4 * indent-tabs-mode: nil * End: */