Home | History | Annotate | Download | only in spdif 
      1 /*
      2  * Copyright 2014, The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #ifndef ANDROID_AUDIO_SPDIF_ENCODER_H
     18 #define ANDROID_AUDIO_SPDIF_ENCODER_H
     19 
     20 #include <stdint.h>
     21 #include <system/audio.h>
     22 #include <audio_utils/spdif/FrameScanner.h>
     23 
     24 namespace android {
     25 
     26 /**
     27  * Scan the incoming byte stream for a frame sync.
     28  * Then wrap the encoded frame in a data burst and send it as if it were PCM.
     29  * The receiver will see the data burst header and decode the wrapped frame.
     30  */
     31 #define SPDIF_MAX_CHANNELS          8
     32 #define SPDIF_ENCODED_CHANNEL_COUNT 2
     33 
     34 class SPDIFEncoder {
     35 public:
     36 
     37     explicit SPDIFEncoder(audio_format_t format);
     38     // Defaults to AC3 format. Was in original API.
     39     SPDIFEncoder();
     40 
     41     virtual ~SPDIFEncoder();
     42 
     43     /**
     44      * Write encoded data to be wrapped for SPDIF.
     45      * The compressed frames do not have to be aligned.
     46      * @return number of bytes written or negative error
     47      */
     48     ssize_t write( const void* buffer, size_t numBytes );
     49 
     50     /**
     51      * Called by SPDIFEncoder when it is ready to output a data burst.
     52      * Must be implemented in the subclass.
     53      * @return number of bytes written or negative error
     54      */
     55     virtual ssize_t writeOutput( const void* buffer, size_t numBytes ) = 0;
     56 
     57     /**
     58      * Get ratio of the encoded data burst sample rate to the encoded rate.
     59      * For example, EAC3 data bursts are 4X the encoded rate.
     60      */
     61     uint32_t getRateMultiplier() const { return mRateMultiplier; }
     62 
     63     /**
     64      * @return number of PCM frames in a data burst
     65      */
     66     uint32_t getBurstFrames() const { return mBurstFrames; }
     67 
     68     /**
     69      * @return number of bytes per PCM frame for the data burst
     70      */
     71     int      getBytesPerOutputFrame();
     72 
     73     /**
     74      * @return  true if we can wrap this format in an SPDIF stream
     75      */
     76     static bool isFormatSupported(audio_format_t format);
     77 
     78     /**
     79      * Discard any data in the buffer. Reset frame scanners.
     80      * This should be called when seeking to a new position in the stream.
     81      */
     82     void reset();
     83 
     84 protected:
     85     void   clearBurstBuffer();
     86     void   writeBurstBufferShorts(const uint16_t* buffer, size_t numBytes);
     87     void   writeBurstBufferBytes(const uint8_t* buffer, size_t numBytes);
     88     void   sendZeroPad();
     89     void   flushBurstBuffer();
     90     void   startDataBurst();
     91     size_t startSyncFrame();
     92 
     93     // Works with various formats including AC3.
     94     FrameScanner *mFramer;
     95 
     96     uint32_t  mSampleRate;
     97     size_t    mFrameSize;   // size of sync frame in bytes
     98     uint16_t *mBurstBuffer; // ALSA wants to get SPDIF data as shorts.
     99     size_t    mBurstBufferSizeBytes;
    100     uint32_t  mRateMultiplier;
    101     uint32_t  mBurstFrames;
    102     size_t    mByteCursor;  // cursor into data burst
    103     int       mBitstreamNumber;
    104     size_t    mPayloadBytesPending; // number of bytes needed to finish burst
    105     // state variable, true if scanning for start of frame
    106     bool      mScanning;
    107 
    108     static const uint16_t kSPDIFSync1; // Pa
    109     static const uint16_t kSPDIFSync2; // Pb
    110 };
    111 
    112 }  // namespace android
    113 
    114 #endif  // ANDROID_AUDIO_SPDIF_ENCODER_H
    115