ROS1 vs ROS2 serialization

edit

Hello,

I am serializing the following msg:

string a
uint8 b
uint8[] c

I am comparing the serialization between ROS1 and ROS2 and I don't know what are the "extra" bytes I get with ROS2:

Serialized ROS1 message: 11 00 00 00 03 00 00 00 41 42 43 0A 05 00 00 00 0B 0C 0D 0E 0F
Serialized ROS2 message: 19 00 00 00 00 01 00 00 04 00 00 00 41 42 43 00 0A 7f 00 00 05 00 00 00 0B 0C 0D 0E 0E

I am also printing the length of the messages (first 4 bytes). Some differences I see:

1. ROS2 adds 00 01 00 00 at the beginning of the message. What are these 4 bytes represent? Are they related to the message?
2. For mytype.a it ends with 00 in ROS2, is it something related to it or I made a mistake somewhere?
3. What are the 3 bytes before the length of mytype.c ? (7f 00 00)?

Here is the code for ROS1:

#include "ros/ros.h"
#include "serialization/mytypes.h"

#include <sstream>
#include <iostream>
#include <fstream>
#include <boost/format.hpp>

namespace ser = ros::serialization;
using namespace std;

serialization::mytypes create_serialization_mytypes();

serialization::mytypes create_serialization_mytypes() {
    serialization::mytypes result;

    result.a = "ABC";
    result.b = 10;
    for(int i=0; i<5; i++){
        result.c.push_back(11+i);
    }
    return result;
}

int main(int argc, char **argv)
{
    ros::init(argc, argv, "node_publisher");
    ros::NodeHandle n;

    serialization::mytypes mytypes;
    mytypes=create_serialization_mytypes();

    uint32_t serial_size = ros::serialization::serializationLength(mytypes);
    boost::shared_array<uint8_t> buffer(new uint8_t[serial_size]);

    ser::OStream stream(buffer.get(), serial_size);
    ser::serialize(stream, mytypes);
    std::cout << "Serialized ROS1 message: ";
    std::cout << std::uppercase << setfill('0') << setw(2) << hex << +(serial_size&0xFF) << " ";
    std::cout << std::uppercase << setfill('0') << setw(2) << hex << +(serial_size>>8&0xFF) << " ";
    std::cout << std::uppercase << setfill('0') << setw(2) << hex << +(serial_size>>16&0xFF) << " ";
    std::cout << std::uppercase << setfill('0') << setw(2) << hex << +(serial_size>>24&0xFF) << " ";
    for(int i=0; i<serial_size; i++){
        std::cout << std::uppercase << setfill('0') << setw(2) << hex << +(buffer[i]) << " ";
    }
    std::cout << endl;

  return 0;
}

And the code for ROS2:

#include <chrono>
#include <memory>

#include "rclcpp/rclcpp.hpp"

#include "rclcpp/serialization.hpp"
#include "serialization/msg/mytypes.hpp"

using namespace std::chrono_literals;

class MinimalPublisher : public rclcpp::Node
{
public:

    serialization::msg::Mytypes create_serialization_mytypes() {
        serialization::msg::Mytypes result;

        result.a = "ABC";
        result.b = 10;
        for(int i=0; i<5; i++){
            result.c.push_back(11+i);
        }
        return result;
    }
  MinimalPublisher()
  : Node("minimal_publisher"), count_(0)
  {
    publisher_ = this->create_publisher<serialization::msg::Mytypes>("topic", 10);    // CHANGE

    // printf("Finished\n");
    timer_ = this->create_wall_timer(
      500ms, std::bind(&MinimalPublisher::timer_callback, this));
  }

private:
  void timer_callback()
  {
    auto message = serialization::msg::Mytypes();
    message = create_serialization_mytypes();

    auto message_header_length = 8u;
    auto message_payload_length = static_cast<size_t>(sizeof(message));
    serialized_msg.reserve(message_header_length + message_payload_length);

    static rclcpp::Serialization<serialization::msg::Mytypes> serializer;
    //serializer.serialize_message(message.get(), &serialized_msg);
    serializer.serialize_message(&message, &serialized_msg);

    printf("Serialized ROS2 message: ");
    printf("%02x ", (serialized_msg.size()&0xFF));
    printf("%02x ", (serialized_msg.size()>>8&0xFF));
    printf ...