Made gyp file for command buffer libraries....

core/cross/command_buffer/texture_cb.cc

 /*
  * Copyright 2009, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 88 matching lines @@
 // Writes the data information into a buffer to be sent to the server side.
 void SetTextureDataBuffer(Texture::Format format,
                           const void* src_data,
                           int src_pitch,
                           unsigned src_width,
                           unsigned src_height,
                           void* dst_buffer,
                           unsigned int dst_pitch) {
   const uint8* src = static_cast<const uint8*>(src_data);
   uint8* dst = static_cast<uint8*>(dst_buffer);
-  size_t bytes_per_line = image::ComputePitch(format, src_width);
-  for (unsigned yy = 0; yy < src_height; ++yy) {
-    memcpy(dst, src, bytes_per_line);
+
+  size_t bytes_per_row = image::ComputePitch(format, src_width);
+  unsigned num_rows = src_height;
+  if (Texture::IsCompressedFormat(format)) {
+    num_rows = (num_rows + 3) / 4;
+  }
+
+  for (unsigned yy = 0; yy < num_rows; ++yy) {
+    memcpy(dst, src, bytes_per_row);
     src += src_pitch;
     dst += dst_pitch;
   }
 }
+
 // Sends the SET_TEXTURE_DATA command after formatting the args properly.
 void SetTextureData(RendererCB *renderer,
                     ResourceID texture_id,
                     unsigned int x,
                     unsigned int y,
                     unsigned int mip_width,
                     unsigned int mip_height,
                     unsigned int z,
                     unsigned int depth,
                     unsigned int level,
@@ skipping 269 matching lines @@
   } else {
     unsigned blocks_across = (mip_width + 3) / 4;
     unsigned bytes_per_block = format() == Texture::DXT1 ? 8 : 16;
     unsigned bytes_per_row = bytes_per_block * blocks_across;
     *pitch = bytes_per_row;
   }
   if (mode != kWriteOnly && !HasLevel(level)) {
     DCHECK_EQ(backing_bitmap_->width(), width());
     DCHECK_EQ(backing_bitmap_->height(), height());
     DCHECK_EQ(backing_bitmap_->format(), format());
-    DCHECK_GT(backing_bitmap_->num_mipmaps(), level);
+    DCHECK_GT(backing_bitmap_->num_mipmaps(), static_cast<unsigned int>(level));
     CopyBackResourceToBitmap(renderer_, resource_id_, level,
                              TextureCUBE::FACE_POSITIVE_X,
                              *backing_bitmap_.Get());
     has_levels_ |= 1 << level;
   }
   locked_levels_ |= 1 << level;
   return true;
 }
 
 // Unlocks the given mipmap level of this texture, uploading the main memory
 // data buffer to the command buffer service.
 bool Texture2DCB::PlatformSpecificUnlock(int level) {
   DCHECK_GE(level, 0);
   DCHECK_LT(level, levels());
   DCHECK(backing_bitmap_->image_data());
   DCHECK_EQ(backing_bitmap_->width(), width());
   DCHECK_EQ(backing_bitmap_->height(), height());
   DCHECK_EQ(backing_bitmap_->format(), format());
-  DCHECK_GT(backing_bitmap_->num_mipmaps(), level);
+  DCHECK_GT(backing_bitmap_->num_mipmaps(), static_cast<unsigned int>(level));
   if (LockedMode(level) != kReadOnly) {
     UpdateResourceFromBitmap(renderer_, resource_id_, level,
                              TextureCUBE::FACE_POSITIVE_X,
                              *backing_bitmap_.Get());
   }
   locked_levels_ &= ~(1 << level);
   if (locked_levels_ == 0) {
     backing_bitmap_->FreeData();
     has_levels_ = 0;
   }
@@ skipping 192 matching lines @@
   } else {
     unsigned blocks_across = (mip_width + 3) / 4;
     unsigned bytes_per_block = format() == Texture::DXT1 ? 8 : 16;
     unsigned bytes_per_row = bytes_per_block * blocks_across;
     *pitch = bytes_per_row;
   }
   if (mode != kWriteOnly && !HasLevel(face, level)) {
     DCHECK_EQ(backing_bitmap->width(), edge_length());
     DCHECK_EQ(backing_bitmap->height(), edge_length());
     DCHECK_EQ(backing_bitmap->format(), format());
-    DCHECK_GT(backing_bitmap->num_mipmaps(), level);
+    DCHECK_GT(backing_bitmap->num_mipmaps(), static_cast<unsigned int>(level));
     CopyBackResourceToBitmap(renderer_, resource_id_, level,
                              TextureCUBE::FACE_POSITIVE_X, *backing_bitmap);
     has_levels_[face] |= 1 << level;
   }
   locked_levels_[face] |= 1 << level;
   return false;
 }
 
 // Unlocks the given face and mipmap level of this texture.
 bool TextureCUBECB::PlatformSpecificUnlock(CubeFace face, int level) {
   DCHECK_GE(level, 0);
   DCHECK_LT(level, levels());
   Bitmap* backing_bitmap = backing_bitmaps_[face].Get();
   DCHECK(backing_bitmap->image_data());
   DCHECK_EQ(backing_bitmap->width(), edge_length());
   DCHECK_EQ(backing_bitmap->height(), edge_length());
   DCHECK_EQ(backing_bitmap->format(), format());
-  DCHECK_GT(backing_bitmap->num_mipmaps(), level);
+  DCHECK_GT(backing_bitmap->num_mipmaps(), static_cast<unsigned int>(level));
 
   if (LockedMode(face, level) != kReadOnly) {
     UpdateResourceFromBitmap(renderer_, resource_id_, level, face,
                              *backing_bitmap);
   }
   locked_levels_[face] &= ~(1 << level);
   if (locked_levels_[face] == 0) {
     backing_bitmap->FreeData();
     has_levels_[face] = 0;
   }
@@ skipping 25 matching lines @@
                                                 face,
                                                 this,
                                                 renderer_));
 }
 
 const Texture::RGBASwizzleIndices& TextureCUBECB::GetABGR32FSwizzleIndices() {
   return g_cb_abgr32f_swizzle_indices;
 }
 
 }  // namespace o3d