path: root/remoting/client/plugin/client.cc

// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "remoting/client/plugin/client.h"

#include <string>
#include <iostream>  // TODO(garykac): Remove this or replace with debug log.

#include "base/logging.h"
#include "media/base/yuv_convert.h"
#include "remoting/client/plugin/chromoting_plugin.h"
#include "remoting/client/plugin/chromotocol.h"
#include "remoting/client/plugin/compression.h"
#include "remoting/client/plugin/decoder.h"
#include "remoting/client/plugin/host_connection.h"

namespace remoting {

ChromotingClient::ChromotingClient(ChromotingPlugin* plugin) {
  plugin_ = plugin;
  host_ = new HostConnection();
  verbose_ = true;
}

ChromotingClient::~ChromotingClient() {
}

void ChromotingClient::hexdump(void* ptr, int buflen) {
  unsigned char* buf = static_cast<unsigned char*>(ptr);
  int i, j;
  for (int i = 0; i < buflen; i += 16) {
    printf("%06x: ", i);
    for (int j = 0; j < 16; j ++)
      if ((i + j) < buflen)
        printf("%02x ", buf[i + j]);
      else
        printf("   ");
    printf(" ");
    for (int j = 0; j < 16; j++)
      if ((i + j) < buflen)
        printf("%c", isprint(buf[i + j]) ? buf[i + j] : '.');
    printf("\n");
  }
}

void ChromotingClient::merge_image(BinaryImageHeader* header, char* data) {
  // Merge this image into the current image.
  // Src bitmap starts at lower left.
  int bytes_per_pixel = 3;
  uint8* src_bitmap = reinterpret_cast<uint8*>(data);
  int src_bytes_per_row = header->width * bytes_per_pixel;

  // Dst bitmap starts at lower left.
  uint8* dst_bitmap = reinterpret_cast<uint8*>(screen_->data.get());
  dst_bitmap += ((header->y * screen_->header.width)
                 + header->x) * bytes_per_pixel;
  int dst_bytes_per_row = screen_->header.width * bytes_per_pixel;

  for (int y = 0; y < header->height; ++y) {
    memcpy(dst_bitmap, src_bitmap, src_bytes_per_row);

    src_bitmap += src_bytes_per_row;
    dst_bitmap += dst_bytes_per_row;
  }
}

// Draw the current image into the given device context.
void ChromotingClient::draw(int width, int height, NPDeviceContext2D* context) {
  if (screen_ != NULL) {
    int max_width = width;
    if (max_width > screen_->header.width) {
      max_width = screen_->header.width;
    }
    int max_height = height;
    if (max_height > screen_->header.height) {
      max_height = screen_->header.height;
    }

    // Src bitmap starts at lower left.
    int bytes_per_pixel = 3;
    int src_bytes_per_row = screen_->header.width * bytes_per_pixel;
    uint8* src_bitmap = reinterpret_cast<uint8*>(screen_->data.get());
    src_bitmap += ((max_height - 1) * src_bytes_per_row);
    uint8* src_row_start = reinterpret_cast<uint8*>(src_bitmap);

    // Dst bitmap (window) starts at upper left.
    uint32* dst_bitmap = static_cast<uint32*>(context->region);
    uint8* dst_row_start = reinterpret_cast<uint8*>(dst_bitmap);
    int dst_bytes_per_row = context->stride;

    for (int y = 0; y < max_height; ++y) {
      for (int x = 0; x < max_width; ++x) {
        uint8 b = (*src_bitmap++ & 0xff);
        uint8 g = (*src_bitmap++ & 0xff);
        uint8 r = (*src_bitmap++ & 0xff);
        uint8 alpha = 0xff;
        *dst_bitmap++ = ((alpha << 24) | (r << 16) | (g << 8) | b);
      }
      src_row_start -= src_bytes_per_row;
      src_bitmap = src_row_start;
      dst_row_start += dst_bytes_per_row;
      dst_bitmap = reinterpret_cast<uint32*>(dst_row_start);
    }
  }
}

bool ChromotingClient::connect_to_host(const std::string ip) {
  if (!host_->connect(ip.c_str())) {
    return false;
  }

  // Process init command.
  InitMessage init_message;
  host_->read_data(reinterpret_cast<char*>(&init_message),
                   sizeof(init_message));
  if (verbose_) {
    std::cout << "Received message " << init_message.message << std::endl;
  }
  if (init_message.message != MessageInit) {
    std::cout << "Expected MessageInit" << std::endl;
    return false;
  }
  if (verbose_) {
    std::cout << "Compression: " << init_message.compression << std::endl;
    std::cout << "Width x height: " << init_message.width << " x "
              << init_message.height << std::endl;
  }

  screen_.reset(new BinaryImage());
  if (!read_image(screen_.get())) {
    return false;
  }

  plugin_->draw();
  return true;
}

void ChromotingClient::print_host_ip_prompt() {
  std::cout << "IP address of host machine: ";
}

// This is called whenever the window changes geometry.
// Currently, we only worry about the first call so we can display our
// login prompt.
void ChromotingClient::set_window() {
  if (!host_->connected()) {
    print_host_ip_prompt();
    std::cout.flush();
  }
}

// Process char input.
void ChromotingClient::handle_char_event(NPPepperEvent* npevent) {
  if (!host_->connected()) {
    handle_login_char(static_cast<char>(npevent->u.character.text[0]));
  }
}

// Process char input before the connection to the host has been made.
// This currently reads the IP address of the host but will eventually
// be changed to read GAIA login credentials.
// Later this will be removed once we have an appropriate web interface for
// discovering hosts.
void ChromotingClient::handle_login_char(char ch) {
  if (ch == 0x0d) {
    std::cout << std::endl;
    if (host_ip_address_.length() == 0) {
      host_ip_address_ = "172.31.11.205";
    }
    if (!connect_to_host(host_ip_address_)) {
      host_ip_address_ = "";
      std::cout << "Unable to connect to host!" << std::endl;
      print_host_ip_prompt();
    } else {
      std::cout << "Connected to " << host_ip_address_ << std::endl;
    }
  } else {
    host_ip_address_ += ch;
    std::cout << ch;
  }
  std::cout.flush();
}

// Process the Pepper mouse event.
void ChromotingClient::handle_mouse_event(NPPepperEvent* npevent) {
  if (host_->connected()) {
    send_mouse_message(npevent);
    if (handle_update_message()) {
      plugin_->draw();
    }
  }
}

// Pass the given Pepper mouse event along to the host.
void ChromotingClient::send_mouse_message(NPPepperEvent* event) {
  NPMouseEvent* mouse_event = &event->u.mouse;
  MouseMessage mouse_msg;

  mouse_msg.message = MessageMouse;
  mouse_msg.x = mouse_event->x;
  mouse_msg.y = mouse_event->y;

  mouse_msg.flags = 0;
  int32 type = event->type;
  int32 button = mouse_event->button;
  if (type == NPEventType_MouseDown) {
    if (button == NPMouseButton_Left) {
      mouse_msg.flags |= LeftDown;
    } else if (button == NPMouseButton_Right) {
      mouse_msg.flags |= RightDown;
    }
  } else if (type == NPEventType_MouseUp) {
    if (button == NPMouseButton_Left) {
      mouse_msg.flags |= LeftUp;
    } else if (button == NPMouseButton_Right) {
      mouse_msg.flags |= RightUp;
    }
  }
  host_->write_data((const char*)&mouse_msg, sizeof(mouse_msg));
}

// Process the pending update command from the host.
// Return true if the screen image has been updated.
bool ChromotingClient::handle_update_message() {
  UpdateMessage update_message;
  int result = host_->read_data(reinterpret_cast<char*>(&update_message),
                                sizeof(update_message));
  if (!result) {
    std::cout << "Failed to get update command" << std::endl;
    return false;
  }

  if (update_message.message != MessageUpdate) {
    std::cout << "Expected MessageUpdate" << std::endl;
    return false;
  }

  if (verbose_) {
    std::cout << "message: " << update_message.message << std::endl;
  }

  if (update_message.compression == CompressionZlib) {
    // Read all data.
    ZDecompressor decomp;
    char buffer[4096];
    int size = update_message.compressed_size;
    while (size > 0) {
      // Determine how much we should read from network.
      int read = std::min(static_cast<int>(sizeof(buffer)), size);
      result = host_->read_data(buffer, read);
      decomp.Write(buffer, read);
      size -= read;
    }
    decomp.Flush();

    // Decompress raw image data and break into individual images.
    char* raw_buffer = decomp.GetRawData();
    int raw_size = decomp.GetRawSize();
    int read = 0;
    BinaryImageHeader header;
    while (read < raw_size) {
      memcpy(&header, raw_buffer, sizeof(BinaryImageHeader));
      if (!check_image_header(&header)) {
        return false;
      }
      read += sizeof(BinaryImageHeader);
      raw_buffer += sizeof(BinaryImageHeader);

      // Merge this image fragment into the screen bitmap.
      merge_image(&header, raw_buffer);

      read += header.size;
      raw_buffer += header.size;
    }
  } else if (update_message.compression == CompressionNone) {
    printf("compressionNone\n");
    for (int i = 0; i < update_message.num_diffs; i++) {
      BinaryImage* image = new BinaryImage();
      read_image(image);

      // Merge this image update into the screen image.
      merge_image(&image->header, image->data.get());

      delete image;
    }
  } else {
    return false;
  }

  return true;
}

// Check the validity of the image header.
bool ChromotingClient::check_image_header(BinaryImageHeader* header) {
  if (header == NULL) {
    std::cout << "Invalid image" << std::endl;
    return false;
  }

  if (header->format != FormatRaw && header->format != FormatVp8) {
    std::cout << "Wrong image format : " << header->format << std::endl;
    return false;
  }

  if (verbose_) {
    std::cout << "Image:" << std::endl;
    std::cout << "  Format " << header->format << std::endl;
    std::cout << "  X,Y " << header->x << ", "
              << header->y << std::endl;
    std::cout << "  WxH " << header->width << " x "
              << header->height << std::endl;
    std::cout << "  Size " << header->size << std::endl;
  }

  return true;
}

// Read an image from the host and store it in the given BinaryImage.
bool ChromotingClient::read_image(BinaryImage* image) {
  int result = host_->read_data(reinterpret_cast<char*>(&image->header),
                                sizeof(image->header));
  if (!result) {
    std::cout << "Failed to receive image header" << std::endl;
    return false;
  }

  if (!check_image_header(&image->header)) {
    return false;
  }

  char* raw_data = new char[image->header.size];
  result = host_->read_data(raw_data, image->header.size);
  if (!result) {
    std::cout << "Failed to receive image data" << std::endl;
    return false;
  }

  if (image->header.format == FormatRaw) {
    // Raw image - all we need to do is load the data, so we're done.
    image->data.reset(raw_data);
    return true;
  } else if (image->header.format == FormatVp8) {
    return false;
    // TODO(hclam): Enable this block of code when we have VP8.
#if 0
    // Vp8 encoded - need to convert YUV image data to RGB.
    static VP8VideoDecoder decoder;
    uint8* planes[3];
    int strides[3];
    printf("decoder.DecodeFrame\n");
    if (!decoder.DecodeFrame(raw_data, image->header.size)) {
      std::cout << "Unable to decode frame" << std::endl;
      return false;
    }
    printf("decoder.GetDecodedFrame\n");
    if (!decoder.GetDecodedFrame(reinterpret_cast<char**>(planes), strides)) {
      std::cout << "Unable to get decoded frame" << std::endl;
      return false;
    }
    printf("width = %d\n", image->header.width);
    for (int i=0; i<3; i++) {
      printf("stride[%d] = %d\n", i, strides[0]);
    }

    // Convert YUV to RGB.
    int width = image->header.width;
    int height = image->header.height;
    char* rgb_data = new char[width * height * sizeof(int32)];
    printf("ConvertYUVToRGB32\n");
    ConvertYUVToRGB32(planes[0], planes[1], planes[2],
                      reinterpret_cast<uint8*>(rgb_data),
                      width,
                      image->header.height,
                      width, // y stride,
                      width / 2,  // uv stride,
                      width * sizeof(int32),  // rgb stride
                      media::YV12);
    printf("conversion done\n");

    image->data.reset(rgb_data);

    // Raw YUV data is no longer needed.
    delete raw_data;
    return true;
#endif
  }

  return false;
}

}  // namespace remoting