1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chromecast/media/cma/ipc/media_message.h" 6 7 #include <limits> 8 9 #include "base/basictypes.h" 10 #include "base/logging.h" 11 #include "chromecast/media/cma/ipc/media_memory_chunk.h" 12 13 namespace chromecast { 14 namespace media { 15 16 // static 17 scoped_ptr<MediaMessage> MediaMessage::CreateDummyMessage( 18 uint32 type) { 19 return scoped_ptr<MediaMessage>( 20 new MediaMessage(type, std::numeric_limits<size_t>::max())); 21 } 22 23 // static 24 scoped_ptr<MediaMessage> MediaMessage::CreateMessage( 25 uint32 type, 26 const MemoryAllocatorCB& memory_allocator, 27 size_t msg_content_capacity) { 28 size_t msg_size = minimum_msg_size() + msg_content_capacity; 29 30 // Make the message size a multiple of the alignment 31 // so that if we have proper alignment for array of messages. 32 size_t end_alignment = msg_size % ALIGNOF(SerializedMsg); 33 if (end_alignment != 0) 34 msg_size += ALIGNOF(SerializedMsg) - end_alignment; 35 36 scoped_ptr<MediaMemoryChunk> memory(memory_allocator.Run(msg_size)); 37 if (!memory) 38 return scoped_ptr<MediaMessage>(); 39 40 return scoped_ptr<MediaMessage>(new MediaMessage(type, memory.Pass())); 41 } 42 43 // static 44 scoped_ptr<MediaMessage> MediaMessage::CreateMessage( 45 uint32 type, 46 scoped_ptr<MediaMemoryChunk> memory) { 47 return scoped_ptr<MediaMessage>(new MediaMessage(type, memory.Pass())); 48 } 49 50 // static 51 scoped_ptr<MediaMessage> MediaMessage::MapMessage( 52 scoped_ptr<MediaMemoryChunk> memory) { 53 return scoped_ptr<MediaMessage>(new MediaMessage(memory.Pass())); 54 } 55 56 MediaMessage::MediaMessage(uint32 type, size_t msg_size) 57 : is_dummy_msg_(true), 58 cached_header_(&cached_msg_.header), 59 msg_(&cached_msg_), 60 msg_read_only_(&cached_msg_), 61 rd_offset_(0) { 62 cached_header_->size = msg_size; 63 cached_header_->type = type; 64 cached_header_->content_size = 0; 65 } 66 67 MediaMessage::MediaMessage(uint32 type, scoped_ptr<MediaMemoryChunk> memory) 68 : is_dummy_msg_(false), 69 cached_header_(&cached_msg_.header), 70 msg_(static_cast<SerializedMsg*>(memory->data())), 71 msg_read_only_(msg_), 72 mem_(memory.Pass()), 73 rd_offset_(0) { 74 CHECK(mem_->valid()); 75 CHECK_GE(mem_->size(), minimum_msg_size()); 76 77 // Check memory alignment: 78 // needed to cast properly |msg_dst| to a SerializedMsg. 79 CHECK_EQ( 80 reinterpret_cast<uintptr_t>(mem_->data()) % ALIGNOF(SerializedMsg), 0u); 81 82 // Make sure that |mem_->data()| + |mem_->size()| is also aligned correctly. 83 // This is needed if we append a second serialized message next to this one. 84 // The second serialized message must be aligned correctly. 85 // It is similar to what a compiler is doing for arrays of structures. 86 CHECK_EQ(mem_->size() % ALIGNOF(SerializedMsg), 0u); 87 88 cached_header_->size = mem_->size(); 89 cached_header_->type = type; 90 cached_header_->content_size = 0; 91 msg_->header = *cached_header_; 92 } 93 94 MediaMessage::MediaMessage(scoped_ptr<MediaMemoryChunk> memory) 95 : is_dummy_msg_(false), 96 cached_header_(&cached_msg_.header), 97 msg_(NULL), 98 msg_read_only_(static_cast<SerializedMsg*>(memory->data())), 99 mem_(memory.Pass()), 100 rd_offset_(0) { 101 CHECK(mem_->valid()); 102 103 // Check memory alignment. 104 CHECK_EQ( 105 reinterpret_cast<uintptr_t>(mem_->data()) % ALIGNOF(SerializedMsg), 0u); 106 107 // Cache the message header which cannot be modified while reading. 108 CHECK_GE(mem_->size(), minimum_msg_size()); 109 *cached_header_ = msg_read_only_->header; 110 CHECK_GE(cached_header_->size, minimum_msg_size()); 111 112 // Make sure if we have 2 consecutive serialized messages in memory, 113 // the 2nd message is also aligned correctly. 114 CHECK_EQ(cached_header_->size % ALIGNOF(SerializedMsg), 0u); 115 116 size_t max_content_size = cached_header_->size - minimum_msg_size(); 117 CHECK_LE(cached_header_->content_size, max_content_size); 118 } 119 120 MediaMessage::~MediaMessage() { 121 } 122 123 bool MediaMessage::IsSerializedMsgAvailable() const { 124 return !is_dummy_msg_ && mem_->valid(); 125 } 126 127 bool MediaMessage::WriteBuffer(const void* src, size_t size) { 128 // No message to write into. 129 if (!msg_) 130 return false; 131 132 // The underlying memory was invalidated. 133 if (!is_dummy_msg_ && !mem_->valid()) 134 return false; 135 136 size_t max_content_size = cached_header_->size - minimum_msg_size(); 137 if (cached_header_->content_size + size > max_content_size) { 138 cached_header_->content_size = max_content_size; 139 msg_->header.content_size = cached_header_->content_size; 140 return false; 141 } 142 143 // Write the message only for non-dummy messages. 144 if (!is_dummy_msg_) { 145 uint8* wr_ptr = &msg_->content + cached_header_->content_size; 146 memcpy(wr_ptr, src, size); 147 } 148 149 cached_header_->content_size += size; 150 msg_->header.content_size = cached_header_->content_size; 151 return true; 152 } 153 154 bool MediaMessage::ReadBuffer(void* dst, size_t size) { 155 // No read possible for a dummy message. 156 if (is_dummy_msg_) 157 return false; 158 159 // The underlying memory was invalidated. 160 if (!mem_->valid()) 161 return false; 162 163 if (rd_offset_ + size > cached_header_->content_size) { 164 rd_offset_ = cached_header_->content_size; 165 return false; 166 } 167 168 const uint8* rd_ptr = &msg_read_only_->content + rd_offset_; 169 memcpy(dst, rd_ptr, size); 170 rd_offset_ += size; 171 return true; 172 } 173 174 void* MediaMessage::GetWritableBuffer(size_t size) { 175 // No read possible for a dummy message. 176 if (is_dummy_msg_) 177 return NULL; 178 179 // The underlying memory was invalidated. 180 if (!mem_->valid()) 181 return NULL; 182 183 if (rd_offset_ + size > cached_header_->content_size) { 184 rd_offset_ = cached_header_->content_size; 185 return NULL; 186 } 187 188 uint8* rd_ptr = &msg_read_only_->content + rd_offset_; 189 rd_offset_ += size; 190 return rd_ptr; 191 } 192 193 const void* MediaMessage::GetBuffer(size_t size) { 194 return GetWritableBuffer(size); 195 } 196 197 } // namespace media 198 } // namespace chromecast 199