Ignore:
Timestamp:
Mar 5, 2009 6:02:28 PM (11 years ago)
Author:
bennylp
Message:

Ticket #736 (aps-direct branch): implemented the compatibility layer for the old sound API

File:
1 edited

Legend:

Unmodified
Added
Removed
  • pjproject/branches/projects/aps-direct/pjmedia/include/pjmedia/port.h

    r2470 r2489  
    223223 
    224224 
    225 /**  
    226  * Types of media frame.  
    227  */ 
    228 typedef enum pjmedia_frame_type 
    229 { 
    230     PJMEDIA_FRAME_TYPE_NONE,        /**< No frame.              */ 
    231     PJMEDIA_FRAME_TYPE_AUDIO,       /**< Normal audio frame.    */ 
    232     PJMEDIA_FRAME_TYPE_EXTENDED     /**< Extended audio frame.  */ 
    233  
    234 } pjmedia_frame_type; 
    235  
    236  
    237 /**  
    238  * This structure describes a media frame.  
    239  */ 
    240 typedef struct pjmedia_frame 
    241 { 
    242     pjmedia_frame_type   type;      /**< Frame type.                        */ 
    243     void                *buf;       /**< Pointer to buffer.                 */ 
    244     pj_size_t            size;      /**< Frame size in bytes.               */ 
    245     pj_timestamp         timestamp; /**< Frame timestamp.                   */ 
    246     pj_uint32_t          bit_info;  /**< Bit info of the frame, sample case: 
    247                                          a frame may not exactly start and end 
    248                                          at the octet boundary, so this field  
    249                                          may be used for specifying start &  
    250                                          end bit offset.                    */ 
    251 } pjmedia_frame; 
    252  
    253  
    254 /** 
    255  * The pjmedia_frame_ext is used to carry a more complex audio frames than 
    256  * the typical PCM audio frames, and it is signaled by setting the "type" 
    257  * field of a pjmedia_frame to PJMEDIA_FRAME_TYPE_EXTENDED. With this set, 
    258  * application may typecast pjmedia_frame to pjmedia_frame_ext. 
    259  * 
    260  * This structure may contain more than one audio frames, which subsequently 
    261  * will be called subframes in this structure. The subframes section 
    262  * immediately follows the end of this structure, and each subframe is 
    263  * represented by pjmedia_frame_ext_subframe structure. Every next 
    264  * subframe immediately follows the previous subframe, and all subframes 
    265  * are byte-aligned although its payload may not be byte-aligned. 
    266  */ 
    267  
    268 #pragma pack(1) 
    269 typedef struct pjmedia_frame_ext { 
    270     pjmedia_frame   base;           /**< Base frame info */ 
    271     pj_uint16_t     samples_cnt;    /**< Number of samples in this frame */ 
    272     pj_uint16_t     subframe_cnt;   /**< Number of (sub)frames in this frame */ 
    273  
    274     /* Zero or more (sub)frames follows immediately after this, 
    275      * each will be represented by pjmedia_frame_ext_subframe 
    276      */ 
    277 } pjmedia_frame_ext; 
    278 #pragma pack() 
    279  
    280 /** 
    281  * This structure represents the individual subframes in the 
    282  * pjmedia_frame_ext structure. 
    283  */ 
    284 #pragma pack(1) 
    285 typedef struct pjmedia_frame_ext_subframe { 
    286     pj_uint16_t     bitlen;         /**< Number of bits in the data */ 
    287     pj_uint8_t      data[1];        /**< Start of encoded data */ 
    288 } pjmedia_frame_ext_subframe; 
    289  
    290 #pragma pack() 
    291  
    292  
    293 /** 
    294  * Append one subframe to #pjmedia_frame_ext. 
    295  * 
    296  * @param frm               The #pjmedia_frame_ext. 
    297  * @param src               Subframe data. 
    298  * @param bitlen            Lenght of subframe, in bits. 
    299  * @param samples_cnt       Number of audio samples in subframe. 
    300  */ 
    301 PJ_INLINE(void) pjmedia_frame_ext_append_subframe(pjmedia_frame_ext *frm, 
    302                                                   const void *src, 
    303                                                   unsigned bitlen, 
    304                                                   unsigned samples_cnt) 
    305 { 
    306     pjmedia_frame_ext_subframe *fsub; 
    307     pj_uint8_t *p; 
    308     unsigned i; 
    309  
    310     p = (pj_uint8_t*)frm + sizeof(pjmedia_frame_ext); 
    311     for (i = 0; i < frm->subframe_cnt; ++i) { 
    312         fsub = (pjmedia_frame_ext_subframe*) p; 
    313         p += sizeof(fsub->bitlen) + ((fsub->bitlen+7) >> 3); 
    314     } 
    315  
    316     fsub = (pjmedia_frame_ext_subframe*) p; 
    317     fsub->bitlen = (pj_uint16_t)bitlen; 
    318     if (bitlen) 
    319         pj_memcpy(fsub->data, src, (bitlen+7) >> 3); 
    320  
    321     frm->subframe_cnt++; 
    322     frm->samples_cnt = (pj_uint16_t)(frm->samples_cnt + samples_cnt); 
    323 } 
    324  
    325 /** 
    326  * Get a subframe from #pjmedia_frame_ext. 
    327  * 
    328  * @param frm               The #pjmedia_frame_ext. 
    329  * @param n                 Subframe index, zero based. 
    330  * 
    331  * @return                  The n-th subframe, or NULL if n is out-of-range. 
    332  */ 
    333 PJ_INLINE(pjmedia_frame_ext_subframe*)  
    334 pjmedia_frame_ext_get_subframe(const pjmedia_frame_ext *frm, unsigned n) 
    335 { 
    336     pjmedia_frame_ext_subframe *sf = NULL; 
    337  
    338     if (n < frm->subframe_cnt) { 
    339         pj_uint8_t *p; 
    340         unsigned i; 
    341  
    342         p = (pj_uint8_t*)frm + sizeof(pjmedia_frame_ext); 
    343         for (i = 0; i < n; ++i) {        
    344             sf = (pjmedia_frame_ext_subframe*) p; 
    345             p += sizeof(sf->bitlen) + ((sf->bitlen+7) >> 3); 
    346         } 
    347          
    348         sf = (pjmedia_frame_ext_subframe*) p; 
    349     } 
    350  
    351     return sf; 
    352 } 
    353          
    354 /** 
    355  * Extract all frame payload to the specified buffer.  
    356  * 
    357  * @param frm               The frame. 
    358  * @param dst               Destination buffer. 
    359  * @param maxsize           Maximum size to copy (i.e. the size of the 
    360  *                          destination buffer). 
    361  * 
    362  * @return                  Total size of payload copied. 
    363  */ 
    364 PJ_INLINE(unsigned)  
    365 pjmedia_frame_ext_copy_payload(const pjmedia_frame_ext *frm, 
    366                                void *dst,  
    367                                unsigned maxlen) 
    368 { 
    369     unsigned i, copied=0; 
    370     for (i=0; i<frm->subframe_cnt; ++i) { 
    371         pjmedia_frame_ext_subframe *sf; 
    372         unsigned sz; 
    373  
    374         sf = pjmedia_frame_ext_get_subframe(frm, i); 
    375         if (!sf) 
    376             continue; 
    377  
    378         sz = ((sf->bitlen + 7) >> 3); 
    379         if (sz + copied > maxlen) 
    380             break; 
    381  
    382         pj_memcpy(((pj_uint8_t*)dst) + copied, sf->data, sz); 
    383         copied += sz; 
    384     } 
    385     return copied; 
    386 } 
    387  
    388  
    389 /** 
    390  * Pop out first n subframes from #pjmedia_frame_ext. 
    391  * 
    392  * @param frm               The #pjmedia_frame_ext. 
    393  * @param n                 Number of first subframes to be popped out. 
    394  * 
    395  * @return                  PJ_SUCCESS when successful. 
    396  */ 
    397 PJ_INLINE(pj_status_t)  
    398 pjmedia_frame_ext_pop_subframes(pjmedia_frame_ext *frm, unsigned n) 
    399 { 
    400     pjmedia_frame_ext_subframe *sf; 
    401     pj_uint8_t *move_src; 
    402     unsigned move_len; 
    403  
    404     if (frm->subframe_cnt <= n) { 
    405         frm->subframe_cnt = 0; 
    406         frm->samples_cnt = 0; 
    407         return PJ_SUCCESS; 
    408     } 
    409  
    410     move_src = (pj_uint8_t*)pjmedia_frame_ext_get_subframe(frm, n); 
    411     sf = pjmedia_frame_ext_get_subframe(frm, frm->subframe_cnt-1); 
    412     move_len = (pj_uint8_t*)sf - move_src + sizeof(sf->bitlen) +  
    413                ((sf->bitlen+7) >> 3); 
    414     pj_memmove((pj_uint8_t*)frm+sizeof(pjmedia_frame_ext),  
    415                move_src, move_len); 
    416              
    417     frm->samples_cnt = (pj_uint16_t) 
    418                    (frm->samples_cnt - n*frm->samples_cnt/frm->subframe_cnt); 
    419     frm->subframe_cnt = (pj_uint16_t) (frm->subframe_cnt - n); 
    420  
    421     return PJ_SUCCESS; 
    422 } 
    423  
    424225/** 
    425226 * Port interface. 
Note: See TracChangeset for help on using the changeset viewer.