sfntly/table/bitmap/eblc_table.cc - platform/external/chromium_org/third_party/sfntly/cpp/src - Git at Google

 /*
  * Copyright 2011 Google Inc. All Rights Reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "sfntly/table/bitmap/eblc_table.h"

 #include <stdio.h>
 #include <stdlib.h>

 #include "sfntly/math/font_math.h"

 namespace sfntly {
 /******************************************************************************
  * EblcTable class
  ******************************************************************************/
 int32_t EblcTable::Version() {
   return data_->ReadFixed(Offset::kVersion);
 }

 int32_t EblcTable::NumSizes() {
   return data_->ReadULongAsInt(Offset::kNumSizes);
 }

 BitmapSizeTable* EblcTable::GetBitmapSizeTable(int32_t index) {
   if (index < 0 || index > NumSizes()) {
 #if !defined (SFNTLY_NO_EXCEPTION)
     throw IndexOutOfBoundException(
         "Size table index is outside the range of tables.");
 #endif
     return NULL;
   }
   BitmapSizeTableList* bitmap_size_table_list = GetBitmapSizeTableList();
   if (bitmap_size_table_list) {
     return (*bitmap_size_table_list)[index];
   }
   return NULL;
 }

 EblcTable::EblcTable(Header* header, ReadableFontData* data)
     : SubTableContainerTable(header, data) {
 }

 BitmapSizeTableList* EblcTable::GetBitmapSizeTableList() {
   AutoLock lock(bitmap_size_table_lock_);
   if (bitmap_size_table_.empty()) {
     CreateBitmapSizeTable(data_, NumSizes(), &bitmap_size_table_);
   }
   return &bitmap_size_table_;
 }

 // static
 void EblcTable::CreateBitmapSizeTable(ReadableFontData* data,
                                       int32_t num_sizes,
                                       BitmapSizeTableList* output) {
   assert(data);
   assert(output);
   for (int32_t i = 0; i < num_sizes; ++i) {
     ReadableFontDataPtr new_data;
     new_data.Attach(down_cast<ReadableFontData*>(
         data->Slice(Offset::kBitmapSizeTableArrayStart +
                     i * Offset::kBitmapSizeTableLength,
                     Offset::kBitmapSizeTableLength)));
     BitmapSizeTableBuilderPtr size_builder;
     size_builder.Attach(
         BitmapSizeTable::Builder::CreateBuilder(new_data, data));
     BitmapSizeTablePtr size;
     size.Attach(down_cast<BitmapSizeTable*>(size_builder->Build()));
     output->push_back(size);
   }
 }

 /******************************************************************************
  * EblcTable::Builder class
  ******************************************************************************/
 EblcTable::Builder::Builder(Header* header, WritableFontData* data)
     : SubTableContainerTable::Builder(header, data) {
 }

 EblcTable::Builder::Builder(Header* header, ReadableFontData* data)
     : SubTableContainerTable::Builder(header, data) {
 }

 EblcTable::Builder::~Builder() {
 }

 int32_t EblcTable::Builder::SubSerialize(WritableFontData* new_data) {
   // header
   int32_t size = new_data->WriteFixed(0, kVersion);
   size += new_data->WriteULong(size, size_table_builders_.size());

   // calculate the offsets
   // offset to the start of the size table array
   int32_t size_table_start_offset = size;
   // walking offset in the size table array
   int32_t size_table_offset = size_table_start_offset;
   // offset to the start of the whole index subtable block
   int32_t sub_table_block_start_offset = size_table_offset +
       size_table_builders_.size() * Offset::kBitmapSizeTableLength;
   // walking offset in the index subtable
   // points to the start of the current subtable block
   int32_t current_sub_table_block_start_offset = sub_table_block_start_offset;

 #if defined (SFNTLY_DEBUG_BITMAP)
   int32_t size_index = 0;
 #endif
   for (BitmapSizeTableBuilderList::iterator
            size_builder = size_table_builders_.begin(),
            size_builder_end = size_table_builders_.end();
        size_builder != size_builder_end; size_builder++) {
     (*size_builder)->SetIndexSubTableArrayOffset(
         current_sub_table_block_start_offset);
     IndexSubTableBuilderList* index_sub_table_builder_list =
         (*size_builder)->IndexSubTableBuilders();

     // walking offset within the current subTable array
     int32_t index_sub_table_array_offset = current_sub_table_block_start_offset;
     // walking offset within the subTable entries
     int32_t index_sub_table_offset = index_sub_table_array_offset +
         index_sub_table_builder_list->size() * Offset::kIndexSubHeaderLength;

 #if defined (SFNTLY_DEBUG_BITMAP)
     fprintf(stderr, "size %d: sizeTable=%x, current subTable Block=%x, ",
             size_index, size_table_offset,
             current_sub_table_block_start_offset);
     fprintf(stderr, "index subTableStart=%x\n", index_sub_table_offset);
     size_index++;
     int32_t sub_table_index = 0;
 #endif
     for (IndexSubTableBuilderList::iterator
              index_sub_table_builder = index_sub_table_builder_list->begin(),
              index_sub_table_builder_end = index_sub_table_builder_list->end();
          index_sub_table_builder != index_sub_table_builder_end;
          index_sub_table_builder++) {
 #if defined (SFNTLY_DEBUG_BITMAP)
       fprintf(stderr, "\tsubTableIndex %d: format=%x, ", sub_table_index,
               (*index_sub_table_builder)->index_format());
       fprintf(stderr, "indexSubTableArrayOffset=%x, indexSubTableOffset=%x\n",
               index_sub_table_array_offset, index_sub_table_offset);
       sub_table_index++;
 #endif
       // array entry
       index_sub_table_array_offset += new_data->WriteUShort(
           index_sub_table_array_offset,
           (*index_sub_table_builder)->first_glyph_index());
       index_sub_table_array_offset += new_data->WriteUShort(
           index_sub_table_array_offset,
           (*index_sub_table_builder)->last_glyph_index());
       index_sub_table_array_offset += new_data->WriteULong(
           index_sub_table_array_offset,
           index_sub_table_offset - current_sub_table_block_start_offset);

       // index sub table
       WritableFontDataPtr slice_index_sub_table;
       slice_index_sub_table.Attach(down_cast<WritableFontData*>(
           new_data->Slice(index_sub_table_offset)));
       int32_t current_sub_table_size =
           (*index_sub_table_builder)->SubSerialize(slice_index_sub_table);
       int32_t padding = FontMath::PaddingRequired(current_sub_table_size,
                                                   DataSize::kULONG);
 #if defined (SFNTLY_DEBUG_BITMAP)
       fprintf(stderr, "\t\tsubTableSize = %x, padding = %x\n",
               current_sub_table_size, padding);
 #endif
       index_sub_table_offset += current_sub_table_size;
       index_sub_table_offset +=
           new_data->WritePadding(index_sub_table_offset, padding);
     }

     // serialize size table
     (*size_builder)->SetIndexTableSize(
         index_sub_table_offset - current_sub_table_block_start_offset);
     WritableFontDataPtr slice_size_table;
     slice_size_table.Attach(down_cast<WritableFontData*>(
         new_data->Slice(size_table_offset)));
     size_table_offset += (*size_builder)->SubSerialize(slice_size_table);

     current_sub_table_block_start_offset = index_sub_table_offset;
   }
   return size + current_sub_table_block_start_offset;
 }

 bool EblcTable::Builder::SubReadyToSerialize() {
   if (size_table_builders_.empty()) {
     return false;
   }
   for (BitmapSizeTableBuilderList::iterator b = size_table_builders_.begin(),
                                             e = size_table_builders_.end();
                                             b != e; b++) {
     if (!(*b)->SubReadyToSerialize()) {
       return false;
     }
   }
   return true;
 }

 int32_t EblcTable::Builder::SubDataSizeToSerialize() {
   if (size_table_builders_.empty()) {
     return 0;
   }
   int32_t size = Offset::kHeaderLength;
   bool variable = false;
 #if defined (SFNTLY_DEBUG_BITMAP)
   size_t size_index = 0;
 #endif
   for (BitmapSizeTableBuilderList::iterator b = size_table_builders_.begin(),
                                             e = size_table_builders_.end();
                                             b != e; b++) {
     int32_t size_builder_size = (*b)->SubDataSizeToSerialize();
 #if defined (SFNTLY_DEBUG_BITMAP)
     fprintf(stderr, "sizeIndex = %d, sizeBuilderSize=0x%x (%d)\n",
             size_index++, size_builder_size, size_builder_size);
 #endif
     variable = size_builder_size > 0 ? variable : true;
     size += abs(size_builder_size);
   }
 #if defined (SFNTLY_DEBUG_BITMAP)
   fprintf(stderr, "eblc size=%d\n", size);
 #endif
   return variable ? -size : size;
 }

 void EblcTable::Builder::SubDataSet() {
   Revert();
 }

 BitmapSizeTableBuilderList* EblcTable::Builder::BitmapSizeBuilders() {
   return GetSizeList();
 }

 void EblcTable::Builder::Revert() {
   size_table_builders_.clear();
   set_model_changed(false);
 }

 void EblcTable::Builder::GenerateLocaList(BitmapLocaList* output) {
   assert(output);
   BitmapSizeTableBuilderList* size_builder_list = GetSizeList();
   output->clear();
 #if defined (SFNTLY_DEBUG_BITMAP)
   int32_t size_index = 0;
 #endif
   for (BitmapSizeTableBuilderList::iterator b = size_builder_list->begin(),
                                             e = size_builder_list->end();
                                             b != e; b++) {
 #if defined (SFNTLY_DEBUG_BITMAP)
     fprintf(stderr, "size table = %d\n", size_index++);
 #endif
     BitmapGlyphInfoMap loca_map;
     (*b)->GenerateLocaMap(&loca_map);
     output->push_back(loca_map);
   }
 }

 CALLER_ATTACH
 FontDataTable* EblcTable::Builder::SubBuildTable(ReadableFontData* data) {
   Ptr<EblcTable> new_table = new EblcTable(header(), data);
   return new_table.Detach();
 }

 // static
 CALLER_ATTACH EblcTable::Builder*
     EblcTable::Builder::CreateBuilder(Header* header, WritableFontData* data) {
   Ptr<EblcTable::Builder> new_builder = new EblcTable::Builder(header, data);
   return new_builder.Detach();
 }

 // static
 CALLER_ATTACH EblcTable::Builder*
     EblcTable::Builder::CreateBuilder(Header* header, ReadableFontData* data) {
   Ptr<EblcTable::Builder> new_builder = new EblcTable::Builder(header, data);
   return new_builder.Detach();
 }

 BitmapSizeTableBuilderList* EblcTable::Builder::GetSizeList() {
   if (size_table_builders_.empty()) {
     Initialize(InternalReadData(), &size_table_builders_);
     set_model_changed();
   }
   return &size_table_builders_;
 }

 void EblcTable::Builder::Initialize(ReadableFontData* data,
                                     BitmapSizeTableBuilderList* output) {
   assert(output);
   if (data) {
     int32_t num_sizes = data->ReadULongAsInt(Offset::kNumSizes);
     for (int32_t i = 0; i < num_sizes; ++i) {
       ReadableFontDataPtr new_data;
       new_data.Attach(down_cast<ReadableFontData*>(
           data->Slice(Offset::kBitmapSizeTableArrayStart +
                       i * Offset::kBitmapSizeTableLength,
                       Offset::kBitmapSizeTableLength)));
       BitmapSizeTableBuilderPtr size_builder;
       size_builder.Attach(BitmapSizeTable::Builder::CreateBuilder(
           new_data, data));
       output->push_back(size_builder);
     }
   }
 }

 }  // namespace sfntly
	/*
	* Copyright 2011 Google Inc. All Rights Reserved.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "sfntly/table/bitmap/eblc_table.h"

	#include <stdio.h>
	#include <stdlib.h>

	#include "sfntly/math/font_math.h"

	namespace sfntly {
	/******************************************************************************
	* EblcTable class
	******************************************************************************/
	int32_t EblcTable::Version() {
	return data_->ReadFixed(Offset::kVersion);
	}

	int32_t EblcTable::NumSizes() {
	return data_->ReadULongAsInt(Offset::kNumSizes);
	}

	BitmapSizeTable* EblcTable::GetBitmapSizeTable(int32_t index) {
	if (index < 0 \|\| index > NumSizes()) {
	#if !defined (SFNTLY_NO_EXCEPTION)
	throw IndexOutOfBoundException(
	"Size table index is outside the range of tables.");
	#endif
	return NULL;
	}
	BitmapSizeTableList* bitmap_size_table_list = GetBitmapSizeTableList();
	if (bitmap_size_table_list) {
	return (*bitmap_size_table_list)[index];
	}
	return NULL;
	}

	EblcTable::EblcTable(Header* header, ReadableFontData* data)
	: SubTableContainerTable(header, data) {
	}

	BitmapSizeTableList* EblcTable::GetBitmapSizeTableList() {
	AutoLock lock(bitmap_size_table_lock_);
	if (bitmap_size_table_.empty()) {
	CreateBitmapSizeTable(data_, NumSizes(), &bitmap_size_table_);
	}
	return &bitmap_size_table_;
	}

	// static
	void EblcTable::CreateBitmapSizeTable(ReadableFontData* data,
	int32_t num_sizes,
	BitmapSizeTableList* output) {
	assert(data);
	assert(output);
	for (int32_t i = 0; i < num_sizes; ++i) {
	ReadableFontDataPtr new_data;
	new_data.Attach(down_cast<ReadableFontData*>(
	data->Slice(Offset::kBitmapSizeTableArrayStart +
	i * Offset::kBitmapSizeTableLength,
	Offset::kBitmapSizeTableLength)));
	BitmapSizeTableBuilderPtr size_builder;
	size_builder.Attach(
	BitmapSizeTable::Builder::CreateBuilder(new_data, data));
	BitmapSizeTablePtr size;
	size.Attach(down_cast<BitmapSizeTable*>(size_builder->Build()));
	output->push_back(size);
	}
	}

	/******************************************************************************
	* EblcTable::Builder class
	******************************************************************************/
	EblcTable::Builder::Builder(Header* header, WritableFontData* data)
	: SubTableContainerTable::Builder(header, data) {
	}

	EblcTable::Builder::Builder(Header* header, ReadableFontData* data)
	: SubTableContainerTable::Builder(header, data) {
	}

	EblcTable::Builder::~Builder() {
	}

	int32_t EblcTable::Builder::SubSerialize(WritableFontData* new_data) {
	// header
	int32_t size = new_data->WriteFixed(0, kVersion);
	size += new_data->WriteULong(size, size_table_builders_.size());

	// calculate the offsets
	// offset to the start of the size table array
	int32_t size_table_start_offset = size;
	// walking offset in the size table array
	int32_t size_table_offset = size_table_start_offset;
	// offset to the start of the whole index subtable block
	int32_t sub_table_block_start_offset = size_table_offset +
	size_table_builders_.size() * Offset::kBitmapSizeTableLength;
	// walking offset in the index subtable
	// points to the start of the current subtable block
	int32_t current_sub_table_block_start_offset = sub_table_block_start_offset;

	#if defined (SFNTLY_DEBUG_BITMAP)
	int32_t size_index = 0;
	#endif
	for (BitmapSizeTableBuilderList::iterator
	size_builder = size_table_builders_.begin(),
	size_builder_end = size_table_builders_.end();
	size_builder != size_builder_end; size_builder++) {
	(*size_builder)->SetIndexSubTableArrayOffset(
	current_sub_table_block_start_offset);
	IndexSubTableBuilderList* index_sub_table_builder_list =
	(*size_builder)->IndexSubTableBuilders();

	// walking offset within the current subTable array
	int32_t index_sub_table_array_offset = current_sub_table_block_start_offset;
	// walking offset within the subTable entries
	int32_t index_sub_table_offset = index_sub_table_array_offset +
	index_sub_table_builder_list->size() * Offset::kIndexSubHeaderLength;

	#if defined (SFNTLY_DEBUG_BITMAP)
	fprintf(stderr, "size %d: sizeTable=%x, current subTable Block=%x, ",
	size_index, size_table_offset,
	current_sub_table_block_start_offset);
	fprintf(stderr, "index subTableStart=%x\n", index_sub_table_offset);
	size_index++;
	int32_t sub_table_index = 0;
	#endif
	for (IndexSubTableBuilderList::iterator
	index_sub_table_builder = index_sub_table_builder_list->begin(),
	index_sub_table_builder_end = index_sub_table_builder_list->end();
	index_sub_table_builder != index_sub_table_builder_end;
	index_sub_table_builder++) {
	#if defined (SFNTLY_DEBUG_BITMAP)
	fprintf(stderr, "\tsubTableIndex %d: format=%x, ", sub_table_index,
	(*index_sub_table_builder)->index_format());
	fprintf(stderr, "indexSubTableArrayOffset=%x, indexSubTableOffset=%x\n",
	index_sub_table_array_offset, index_sub_table_offset);
	sub_table_index++;
	#endif
	// array entry
	index_sub_table_array_offset += new_data->WriteUShort(
	index_sub_table_array_offset,
	(*index_sub_table_builder)->first_glyph_index());
	index_sub_table_array_offset += new_data->WriteUShort(
	index_sub_table_array_offset,
	(*index_sub_table_builder)->last_glyph_index());
	index_sub_table_array_offset += new_data->WriteULong(
	index_sub_table_array_offset,
	index_sub_table_offset - current_sub_table_block_start_offset);

	// index sub table
	WritableFontDataPtr slice_index_sub_table;
	slice_index_sub_table.Attach(down_cast<WritableFontData*>(
	new_data->Slice(index_sub_table_offset)));
	int32_t current_sub_table_size =
	(*index_sub_table_builder)->SubSerialize(slice_index_sub_table);
	int32_t padding = FontMath::PaddingRequired(current_sub_table_size,
	DataSize::kULONG);
	#if defined (SFNTLY_DEBUG_BITMAP)
	fprintf(stderr, "\t\tsubTableSize = %x, padding = %x\n",
	current_sub_table_size, padding);
	#endif
	index_sub_table_offset += current_sub_table_size;
	index_sub_table_offset +=
	new_data->WritePadding(index_sub_table_offset, padding);
	}

	// serialize size table
	(*size_builder)->SetIndexTableSize(
	index_sub_table_offset - current_sub_table_block_start_offset);
	WritableFontDataPtr slice_size_table;
	slice_size_table.Attach(down_cast<WritableFontData*>(
	new_data->Slice(size_table_offset)));
	size_table_offset += (*size_builder)->SubSerialize(slice_size_table);

	current_sub_table_block_start_offset = index_sub_table_offset;
	}
	return size + current_sub_table_block_start_offset;
	}

	bool EblcTable::Builder::SubReadyToSerialize() {
	if (size_table_builders_.empty()) {
	return false;
	}
	for (BitmapSizeTableBuilderList::iterator b = size_table_builders_.begin(),
	e = size_table_builders_.end();
	b != e; b++) {
	if (!(*b)->SubReadyToSerialize()) {
	return false;
	}
	}
	return true;
	}

	int32_t EblcTable::Builder::SubDataSizeToSerialize() {
	if (size_table_builders_.empty()) {
	return 0;
	}
	int32_t size = Offset::kHeaderLength;
	bool variable = false;
	#if defined (SFNTLY_DEBUG_BITMAP)
	size_t size_index = 0;
	#endif
	for (BitmapSizeTableBuilderList::iterator b = size_table_builders_.begin(),
	e = size_table_builders_.end();
	b != e; b++) {
	int32_t size_builder_size = (*b)->SubDataSizeToSerialize();
	#if defined (SFNTLY_DEBUG_BITMAP)
	fprintf(stderr, "sizeIndex = %d, sizeBuilderSize=0x%x (%d)\n",
	size_index++, size_builder_size, size_builder_size);
	#endif
	variable = size_builder_size > 0 ? variable : true;
	size += abs(size_builder_size);
	}
	#if defined (SFNTLY_DEBUG_BITMAP)
	fprintf(stderr, "eblc size=%d\n", size);
	#endif
	return variable ? -size : size;
	}

	void EblcTable::Builder::SubDataSet() {
	Revert();
	}

	BitmapSizeTableBuilderList* EblcTable::Builder::BitmapSizeBuilders() {
	return GetSizeList();
	}

	void EblcTable::Builder::Revert() {
	size_table_builders_.clear();
	set_model_changed(false);
	}

	void EblcTable::Builder::GenerateLocaList(BitmapLocaList* output) {
	assert(output);
	BitmapSizeTableBuilderList* size_builder_list = GetSizeList();
	output->clear();
	#if defined (SFNTLY_DEBUG_BITMAP)
	int32_t size_index = 0;
	#endif
	for (BitmapSizeTableBuilderList::iterator b = size_builder_list->begin(),
	e = size_builder_list->end();
	b != e; b++) {
	#if defined (SFNTLY_DEBUG_BITMAP)
	fprintf(stderr, "size table = %d\n", size_index++);
	#endif
	BitmapGlyphInfoMap loca_map;
	(*b)->GenerateLocaMap(&loca_map);
	output->push_back(loca_map);
	}
	}

	CALLER_ATTACH
	FontDataTable* EblcTable::Builder::SubBuildTable(ReadableFontData* data) {
	Ptr<EblcTable> new_table = new EblcTable(header(), data);
	return new_table.Detach();
	}

	// static
	CALLER_ATTACH EblcTable::Builder*
	EblcTable::Builder::CreateBuilder(Header* header, WritableFontData* data) {
	Ptr<EblcTable::Builder> new_builder = new EblcTable::Builder(header, data);
	return new_builder.Detach();
	}

	// static
	CALLER_ATTACH EblcTable::Builder*
	EblcTable::Builder::CreateBuilder(Header* header, ReadableFontData* data) {
	Ptr<EblcTable::Builder> new_builder = new EblcTable::Builder(header, data);
	return new_builder.Detach();
	}

	BitmapSizeTableBuilderList* EblcTable::Builder::GetSizeList() {
	if (size_table_builders_.empty()) {
	Initialize(InternalReadData(), &size_table_builders_);
	set_model_changed();
	}
	return &size_table_builders_;
	}

	void EblcTable::Builder::Initialize(ReadableFontData* data,
	BitmapSizeTableBuilderList* output) {
	assert(output);
	if (data) {
	int32_t num_sizes = data->ReadULongAsInt(Offset::kNumSizes);
	for (int32_t i = 0; i < num_sizes; ++i) {
	ReadableFontDataPtr new_data;
	new_data.Attach(down_cast<ReadableFontData*>(
	data->Slice(Offset::kBitmapSizeTableArrayStart +
	i * Offset::kBitmapSizeTableLength,
	Offset::kBitmapSizeTableLength)));
	BitmapSizeTableBuilderPtr size_builder;
	size_builder.Attach(BitmapSizeTable::Builder::CreateBuilder(
	new_data, data));
	output->push_back(size_builder);
	}
	}
	}

	} // namespace sfntly