Home | History | Annotate | Download | only in src 
      1 /* ------------------------------------------------------------------
      2  * Copyright (C) 1998-2009 PacketVideo
      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
     13  * express or implied.
     14  * See the License for the specific language governing permissions
     15  * and limitations under the License.
     16  * -------------------------------------------------------------------
     17  */
     18 // -*- c++ -*-
     19 #ifndef PVMF_RETURN_CODES_H_INCLUDED
     20 #include "pvmf_return_codes.h"
     21 #endif
     22 
     23 #include "media_packet.h"
     24 
     25 OSCL_EXPORT_REF MediaFragment* MediaPacket::GetMediaFragment(int32 idx, MediaFragment& fragment)
     26 {
     27     BufferState * state = GetBufferState(idx);
     28     /*if(!state)
     29         return NULL;*/
     30     fragment.Set(*GetFragment(idx), state);
     31     return &fragment;
     32 }
     33 
     34 
     35 OSCL_EXPORT_REF BufFragStatusClass::status_t MediaPacket::AddMediaFragment(MediaFragment* fragment, int32 location_offset)
     36 {
     37     return AddFragment(*fragment->GetFragment(), fragment->GetState(), location_offset);
     38 }
     39 
     40 OSCL_EXPORT_REF void MediaPacket::Reset()
     41 {
     42     cur_frag_num = 0;
     43     cur_pos = NULL;
     44     end_pos = NULL;
     45     AppendNext(NULL);
     46 }
     47 
     48 
     49 /* This should change to allocate memory from a memory pool */
     50 OSCL_EXPORT_REF MediaPacket* MediaPacketAllocator::allocate_packet(EPacketType type)
     51 {
     52     OSCL_UNUSED_ARG(type);
     53     return OSCL_NEW(MediaPacket, ());
     54 }
     55 
     56 /* Change to return to pool */
     57 OSCL_EXPORT_REF void MediaPacketAllocator::deallocate_packet(MediaPacket* pack)
     58 {
     59     OSCL_DELETE(pack);
     60 }
     61 
     62 OSCL_EXPORT_REF MediaPacketPoolAllocator::MediaPacketPoolAllocator(int packets)
     63 {
     64     num_packets = packets;
     65 
     66     entire_list = OSCL_ARRAY_NEW(MediaPacket, num_packets);
     67     free_list = entire_list;
     68 
     69     int i;
     70     for (i = 0; i < num_packets; i++)
     71     {
     72         if (i > 0)
     73         {
     74             entire_list[i-1].AppendNext(&entire_list[i]);
     75         }
     76     }
     77     entire_list[i-1].AppendNext(NULL);
     78 
     79 }
     80 
     81 MediaPacketPoolAllocator::~MediaPacketPoolAllocator()
     82 {
     83     if (entire_list) delete[] entire_list;
     84 }
     85 
     86 OSCL_EXPORT_REF MediaPacket *MediaPacketPoolAllocator::allocate_packet(EPacketType type)
     87 {
     88     OSCL_UNUSED_ARG(type);
     89 
     90     MediaPacket *pkt;
     91 
     92     if (free_list)
     93     {
     94         pkt = free_list;
     95         free_list = (MediaPacket *)free_list->GetNext();
     96 
     97         pkt->AppendNext(NULL);
     98 
     99         return pkt;
    100     }
    101     else
    102     {
    103         return NULL;
    104     }
    105 }
    106 
    107 OSCL_EXPORT_REF void MediaPacketPoolAllocator::deallocate_packet(MediaPacket* pack)
    108 {
    109     pack->Clear();
    110     pack->Reset();
    111 
    112     pack->AppendNext(free_list);
    113     free_list = pack;
    114 
    115 }
    116 
    117 OSCL_EXPORT_REF PVMFSharedMediaMsgPtr MediaPacketToPVMFMediaMsg(MediaPacket* packet, PVMFSimpleMediaBufferCombinedAlloc& alloc)
    118 {
    119     if (packet == NULL || packet->GetMediaSize() == 0)
    120     {
    121         OSCL_LEAVE(PVMFErrArgument);
    122     }
    123     uint16 packet_size = (uint16)packet->GetMediaSize();
    124 
    125     // Create new media data buffer
    126     OsclSharedPtr<PVMFMediaDataImpl> mediaDataImpl = alloc.allocate(packet_size);
    127     PVMFSharedMediaDataPtr mediaData = PVMFMediaData::createMediaData(mediaDataImpl);
    128 
    129     // Retrieve memory fragment to write to
    130     OsclRefCounterMemFrag refCtrMemFrag;
    131     mediaData->getMediaFragment(0, refCtrMemFrag);
    132     uint8* copy_pos = (uint8*)refCtrMemFrag.getMemFragPtr();
    133     MediaFragment frag;
    134     for (int frag_num = 0; frag_num < packet->GetNumFrags(); frag_num++)
    135     {
    136         packet->GetMediaFragment(frag_num, frag);
    137         oscl_memcpy(copy_pos, frag.GetPtr(), frag.GetLen());
    138         copy_pos += frag.GetLen();
    139     }
    140 
    141     // update the filled length of the fragment
    142     mediaData->setMediaFragFilledLen(0, packet_size);
    143 
    144     // Send packet to downstream node
    145     PVMFSharedMediaMsgPtr mediaMsg;
    146     convertToPVMFMediaMsg(mediaMsg, mediaData);
    147     return mediaMsg;
    148 }
    149 
    150 /* Callers responsibility to delete the packet */
    151 OSCL_EXPORT_REF MediaPacket* PVMFMediaMsgToMediaPacket(PVMFSharedMediaMsgPtr aMsg,
    152         MediaPacketAllocator& aMediaPacketAlloc, FragmentAllocator& aFragmentAlloc)
    153 {
    154 
    155     PVMFSharedMediaDataPtr mediaData;
    156     convertToPVMFMediaData(mediaData, aMsg);
    157     if (mediaData->getFilledSize() == 0)
    158     {
    159         return NULL;
    160     }
    161 
    162     MediaPacket* packet = aMediaPacketAlloc.allocate_packet();
    163     OSCL_ASSERT(packet->GetNumFrags() == 0);
    164 
    165     MediaFragment *frag = aFragmentAlloc.allocate_fragment(mediaData->getFilledSize());
    166 
    167     OsclRefCounterMemFrag rcmfrag;
    168 
    169     uint8* write_pos = frag->GetPtr();
    170     for (uint16 frag_num = 0; frag_num < mediaData->getNumFragments(); frag_num++)
    171     {
    172         mediaData->getMediaFragment(frag_num, rcmfrag);
    173         oscl_memcpy(write_pos, rcmfrag.getMemFragPtr(), rcmfrag.getMemFragSize());
    174         write_pos += rcmfrag.getMemFragSize();
    175     }
    176 
    177     // add fragment to packet and send
    178     packet->AddMediaFragment(frag);
    179     aFragmentAlloc.deallocate_fragment(frag);
    180 
    181     return packet;
    182 }
    183