diff --git a/lib/micro-jpg/src/jpg.cpp b/lib/micro-jpg/src/jpg.cpp index f2bc309..ef0bef7 100644 --- a/lib/micro-jpg/src/jpg.cpp +++ b/lib/micro-jpg/src/jpg.cpp @@ -53,13 +53,13 @@ bool jpg::decode(const uint8_t *data, size_t size) // First quantization table (Luminance - black & white images) if (!(quantization_table_luminance_ = find_jpg_section(&ptr, end, jpg_section_t::jpg_section_flag::DQT))) { - log_e("No quantization table 0 section found"); + log_e("No quantization_table_luminance section found"); return false; } // Second quantization table (Chrominance - color images) if (!(quantization_table_chrominance_ = find_jpg_section(&ptr, end, jpg_section_t::jpg_section_flag::DQT))) - log_w("No quantization table 1 section found"); + log_w("No quantization_table_chrominance section found"); // Start of scan if (!find_jpg_section(&ptr, end, jpg_section_t::jpg_section_flag::SOS)) @@ -83,7 +83,9 @@ bool jpg::decode(const uint8_t *data, size_t size) return false; } - log_d("Total jpeg data = %d bytes", jpeg_data_end - jpeg_data_start); + jpeg_data_end = ptr; + + log_d("Total jpeg data= %d bytes", jpeg_data_end - jpeg_data_start); return true; } diff --git a/lib/micro-rtsp-server/include/micro_rtsp_camera.h b/lib/micro-rtsp-server/include/micro_rtsp_camera.h index 9800d70..6b4481f 100644 --- a/lib/micro-rtsp-server/include/micro_rtsp_camera.h +++ b/lib/micro-rtsp-server/include/micro_rtsp_camera.h @@ -10,16 +10,15 @@ class micro_rtsp_camera esp_err_t initialize(camera_config_t *camera_config); esp_err_t deinitialize(); - // sensor_t* esp_camera_sensor_get(); void update_frame(); - uint8_t *data() const { return fb->buf; } - size_t width() const { return fb->width; } - size_t height() const { return fb->height; } - size_t size() const { return fb->len; } + uint8_t *data() const { return fb_->buf; } + size_t width() const { return fb_->width; } + size_t height() const { return fb_->height; } + size_t size() const { return fb_->len; } private: - esp_err_t init_result; - camera_fb_t *fb; + esp_err_t init_result_; + camera_fb_t *fb_; }; \ No newline at end of file diff --git a/lib/micro-rtsp-server/include/micro_rtsp_requests.h b/lib/micro-rtsp-server/include/micro_rtsp_requests.h index 0a876bc..e15202b 100644 --- a/lib/micro-rtsp-server/include/micro_rtsp_requests.h +++ b/lib/micro-rtsp-server/include/micro_rtsp_requests.h @@ -18,7 +18,7 @@ class micro_rtsp_requests rtsp_command_teardown // TEARDOWN }; - const std::string available_stream_name_ = "mjpeg/1"; + const char* available_stream_name_ = "mjpeg/1"; rtsp_command parse_command(const std::string &request); bool parse_client_port(const std::string &request); diff --git a/lib/micro-rtsp-server/include/micro_rtsp_streamer.h b/lib/micro-rtsp-server/include/micro_rtsp_streamer.h index cc5b8ab..465162f 100644 --- a/lib/micro-rtsp-server/include/micro_rtsp_streamer.h +++ b/lib/micro-rtsp-server/include/micro_rtsp_streamer.h @@ -8,19 +8,19 @@ constexpr uint8_t RTP_PAYLOAD_JPG = 26; constexpr size_t jpeg_luminance_table_length = 64; constexpr size_t jpeg_chrominance_table_length = 64; -// https://www.ietf.org/rfc/rfc2326#section-10.12 -typedef struct __attribute__((packed)) -{ - char magic; // Magic encapsulation ASCII dollar sign (24 hexadecimal) - uint8_t channel; // Channel identifier - uint16_t length; // Network order -} rtp_over_tcp_hdr_t; - class micro_rtsp_streamer { public: + // https://www.ietf.org/rfc/rfc2326#section-10.12 + typedef struct __attribute__((packed)) + { + char magic; // Magic encapsulation ASCII dollar sign (24 hexadecimal) + uint8_t channel; // Channel identifier + uint16_t length; // Network order + } rtp_over_tcp_hdr_t; + micro_rtsp_streamer(const uint16_t width, const uint16_t height); - rtp_over_tcp_hdr_t *create_jpg_packet(const uint8_t *jpg_scan, const uint8_t *jpg_scan_end, uint8_t **jpg_offset, const uint32_t timestamp, const uint8_t* quantization_table_luminance, const uint8_t* quantization_table_chrominance); + rtp_over_tcp_hdr_t *create_jpg_packet(const uint8_t *jpg_scan, const uint8_t *jpg_scan_end, uint8_t **jpg_offset, const uint32_t timestamp, const uint8_t *quantization_table_luminance, const uint8_t *quantization_table_chrominance); private: uint16_t width_, height_; diff --git a/lib/micro-rtsp-server/src/micro_rtsp_camera.cpp b/lib/micro-rtsp-server/src/micro_rtsp_camera.cpp index f64d995..0ea4462 100644 --- a/lib/micro-rtsp-server/src/micro_rtsp_camera.cpp +++ b/lib/micro-rtsp-server/src/micro_rtsp_camera.cpp @@ -4,7 +4,7 @@ micro_rtsp_camera::micro_rtsp_camera() { - init_result == ESP_FAIL; + init_result_ == ESP_FAIL; } micro_rtsp_camera::~micro_rtsp_camera() @@ -14,24 +14,26 @@ micro_rtsp_camera::~micro_rtsp_camera() esp_err_t micro_rtsp_camera::initialize(camera_config_t *camera_config) { - init_result = esp_camera_init(camera_config); - if (init_result == ESP_OK) + log_v("camera_config={.pin_pwdn:%u,.pin_reset:%u,.pin_xclk:%u,.pin_sccb_sda:%u,.pin_sccb_scl:%u,.pin_d7:%u,.pin_d6:%u,.pin_d5:%u,.pin_d4:%u,.pin_d3:%u,.pin_d2:%u,.pin_d1:%u,.pin_d0:%u,.pin_vsync:%u,.pin_href:%u,.pin_pclk:%u,.xclk_freq_hz:%d,.ledc_timer:%u,ledc_channel:%u,.pixel_format:%d,.frame_size:%d,.jpeg_quality:%d,.fb_count:%d,.fb_location%d,.grab_mode:%d,sccb_i2c_port:%d}", camera_config->pin_pwdn, camera_config->pin_reset, camera_config->pin_xclk, camera_config->pin_sccb_sda, camera_config->pin_sccb_scl, camera_config->pin_d7, camera_config->pin_d6, camera_config->pin_d5, camera_config->pin_d4, camera_config->pin_d3, camera_config->pin_d2, camera_config->pin_d1, camera_config->pin_d0, camera_config->pin_vsync, camera_config->pin_href, camera_config->pin_pclk, camera_config->xclk_freq_hz, camera_config->ledc_timer, camera_config->ledc_channel, camera_config->pixel_format, camera_config->frame_size, camera_config->jpeg_quality, camera_config->fb_count, camera_config->fb_location, camera_config->grab_mode, camera_config->sccb_i2c_port); + + init_result_ = esp_camera_init(camera_config); + if (init_result_ == ESP_OK) update_frame(); else - log_e("Camera initialization failed: 0x%02x", init_result); + log_e("Camera initialization failed: 0x%02x", init_result_); - return init_result; + return init_result_; } esp_err_t micro_rtsp_camera::deinitialize() { - return init_result == ESP_OK ? esp_camera_deinit() : ESP_OK; + return init_result_ == ESP_OK ? esp_camera_deinit() : ESP_OK; } void micro_rtsp_camera::update_frame() { - if (fb) - esp_camera_fb_return(fb); + if (fb_) + esp_camera_fb_return(fb_); - fb = esp_camera_fb_get(); + fb_ = esp_camera_fb_get(); } \ No newline at end of file diff --git a/lib/micro-rtsp-server/src/micro_rtsp_requests.cpp b/lib/micro-rtsp-server/src/micro_rtsp_requests.cpp index 5759eb3..11f0595 100644 --- a/lib/micro-rtsp-server/src/micro_rtsp_requests.cpp +++ b/lib/micro-rtsp-server/src/micro_rtsp_requests.cpp @@ -7,7 +7,7 @@ micro_rtsp_requests::rtsp_command micro_rtsp_requests::parse_command(const std::string &request) { - log_i("parse_command"); + log_v("request: %s", request.c_str()); // Check for RTSP commands: Option, Describe, Setup, Play, Teardown if (std::regex_match(request, std::regex("^OPTION ", std::regex_constants::icase))) @@ -31,7 +31,8 @@ micro_rtsp_requests::rtsp_command micro_rtsp_requests::parse_command(const std:: bool micro_rtsp_requests::parse_client_port(const std::string &request) { - log_i("parse_client_port"); + log_v("request: %s", request.c_str()); + std::regex regex("client_port=([0-9]+)", std::regex_constants::icase); std::smatch match; if (!std::regex_match(request, match, regex)) @@ -46,7 +47,8 @@ bool micro_rtsp_requests::parse_client_port(const std::string &request) bool micro_rtsp_requests::parse_cseq(const std::string &request) { - log_i("parse_cseq"); + log_v("request: %s", request.c_str()); + // CSeq: 2 std::regex regex("CSeq: (\\d+)", std::regex_constants::icase); std::smatch match; @@ -62,7 +64,8 @@ bool micro_rtsp_requests::parse_cseq(const std::string &request) bool micro_rtsp_requests::parse_stream_url(const std::string &request) { - log_i("parse_host_url"); + log_v("request: %s", request.c_str()); + // SETUP rtsp://192.168.10.93:1234/mjpeg/1 RTSP/1.0 std::regex regex("rtsp:\\/\\/([\\w.]+):(\\d+)\\/([\\/\\w]+)\\s+RTSP/1.0", std::regex_constants::icase); std::smatch match; @@ -88,6 +91,8 @@ std::string micro_rtsp_requests::date_header() std::string micro_rtsp_requests::rtsp_error(unsigned short code, const std::string &message) { + log_v("code: %d, message: %s", code, message.c_str()); + std::ostringstream oss; oss << "RTSP/1.0 " << code << " " << message << "\r\n" << "CSeq: " << cseq_ << "\r\n" @@ -98,7 +103,8 @@ std::string micro_rtsp_requests::rtsp_error(unsigned short code, const std::stri std::string micro_rtsp_requests::handle_option(const std::string &request) { - log_i("handle_option"); + log_v("request: %s", request.c_str()); + std::ostringstream oss; oss << "RTSP/1.0 200 OK\r\n" << "CSeq: " << cseq_ << "\r\n" @@ -111,7 +117,8 @@ std::string micro_rtsp_requests::handle_option(const std::string &request) std::string micro_rtsp_requests::handle_describe(const std::string &request) { - log_i("handle_describe"); + log_v("request: %s", request.c_str()); + if (!parse_stream_url(request)) return rtsp_error(400, "Invalid Stream Name"); @@ -141,6 +148,8 @@ std::string micro_rtsp_requests::handle_describe(const std::string &request) std::string micro_rtsp_requests::handle_setup(const std::string &request) { + log_v("request: %s", request.c_str()); + tcp_transport_ = request.find("rtp/avp/tcp") != std::string::npos; if (!parse_client_port(request)) @@ -164,6 +173,8 @@ std::string micro_rtsp_requests::handle_setup(const std::string &request) std::string micro_rtsp_requests::handle_play(const std::string &request) { + log_v("request: %s", request.c_str()); + stream_active_ = true; std::ostringstream oss; oss << "RTSP/1.0 200 OK\r\n" @@ -178,6 +189,8 @@ std::string micro_rtsp_requests::handle_play(const std::string &request) std::string micro_rtsp_requests::handle_teardown(const std::string &request) { + log_v("request: %s", request.c_str()); + stream_stopped_ = true; std::ostringstream oss; oss << "RTSP/1.0 200 OK\r\n" @@ -189,7 +202,8 @@ std::string micro_rtsp_requests::handle_teardown(const std::string &request) std::string micro_rtsp_requests::process_request(const std::string &request) { - log_i("handle_request"); + log_v("request: %s", request.c_str()); + auto command = parse_command(request); if (command != rtsp_command_unknown) { diff --git a/lib/micro-rtsp-server/src/micro_rtsp_server.cpp b/lib/micro-rtsp-server/src/micro_rtsp_server.cpp index b1262a8..9d38ce7 100644 --- a/lib/micro-rtsp-server/src/micro_rtsp_server.cpp +++ b/lib/micro-rtsp-server/src/micro_rtsp_server.cpp @@ -9,7 +9,7 @@ micro_rtsp_server::micro_rtsp_server(micro_rtsp_camera &source, unsigned frame_interval /*= 100*/) : source_(source), streamer_(source.width(), source.height()) { - log_i("starting RTSP server"); + log_v("frame_interval:%d", frame_interval); frame_interval_ = frame_interval; } @@ -34,6 +34,7 @@ void micro_rtsp_server::loop() if (next_check_client_ < now) { + log_v("Check for new client"); next_check_client_ = now + CHECK_CLIENT_INTERVAL; // Check if a client wants to connect @@ -51,6 +52,7 @@ void micro_rtsp_server::loop() if (next_frame_update_ < now) { + log_v("Stream frame"); next_frame_update_ = now + frame_interval_; auto ts = time(nullptr); @@ -62,14 +64,16 @@ void micro_rtsp_server::loop() auto jpg_size = source_.size(); assert(jpg.decode(jpg_data, jpg_size)); - auto jpg_scan_current = (uint8_t*)jpg.jpeg_data_start; + auto jpg_scan_current = (uint8_t *)jpg.jpeg_data_start; while (jpg_scan_current < jpg.jpeg_data_end) { auto packet = streamer_.create_jpg_packet(jpg.jpeg_data_start, jpg.jpeg_data_end, &jpg_scan_current, ts, jpg.quantization_table_luminance_->data, jpg.quantization_table_chrominance_->data); for (auto client : clients_) { - ; - // client->session->broadcastCurrentFrame(now); + log_v("Stream frame to client: 0x%08x", client); + // RTP over TCP encapsulates in a $ + client.write((const uint8_t *)packet, packet->length + sizeof(micro_rtsp_streamer::rtp_over_tcp_hdr_t)); + // TODO: UDP } free(packet); } @@ -79,18 +83,15 @@ void micro_rtsp_server::loop() micro_rtsp_server::rtsp_client::rtsp_client(const WiFiClient &wifi_client) : WiFiClient(wifi_client) { - log_i("rtsp_client"); } micro_rtsp_server::rtsp_client::~rtsp_client() { - log_i("~rtsp_client"); stop(); } void micro_rtsp_server::rtsp_client::handle_request() { - log_i("handle_request"); // Read if data available auto bytes_available = available(); if (bytes_available > 0) diff --git a/lib/micro-rtsp-server/src/micro_rtsp_streamer.cpp b/lib/micro-rtsp-server/src/micro_rtsp_streamer.cpp index 0bd19fd..4ffa206 100644 --- a/lib/micro-rtsp-server/src/micro_rtsp_streamer.cpp +++ b/lib/micro-rtsp-server/src/micro_rtsp_streamer.cpp @@ -7,6 +7,7 @@ micro_rtsp_streamer::micro_rtsp_streamer(const uint16_t width, const uint16_t height) { + log_v("width:%d, height:%d", width, height); width_ = width; height_ = height; // Random number @@ -14,8 +15,10 @@ micro_rtsp_streamer::micro_rtsp_streamer(const uint16_t width, const uint16_t he sequence_number_ = 0; } -rtp_over_tcp_hdr_t *micro_rtsp_streamer::create_jpg_packet(const uint8_t *jpg_scan, const uint8_t *jpg_scan_end, uint8_t **jpg_offset, const uint32_t timestamp, const uint8_t* quantization_table_luminance, const uint8_t* quantization_table_chrominance) +micro_rtsp_streamer::rtp_over_tcp_hdr_t *micro_rtsp_streamer::create_jpg_packet(const uint8_t *jpg_scan, const uint8_t *jpg_scan_end, uint8_t **jpg_offset, const uint32_t timestamp, const uint8_t *quantization_table_luminance, const uint8_t *quantization_table_chrominance) { + log_v("jpg_scan:0x%08x, jpg_scan_end:0x%08x, jpg_offset:0x%08x, timestamp:%d, quantization_table_luminance:0x%08x, quantization_table_chrominance:0x%08x", jpg_scan, jpg_scan_end, jpg_offset, timestamp, quantization_table_luminance, quantization_table_chrominance); + // The MTU of wireless networks is 2,312 bytes. This size includes the packet headers. const auto isFirstFragment = jpg_scan == *jpg_offset; const auto include_quantization_tables = isFirstFragment && quantization_table_luminance != nullptr && quantization_table_chrominance != nullptr; @@ -31,44 +34,37 @@ rtp_over_tcp_hdr_t *micro_rtsp_streamer::create_jpg_packet(const uint8_t *jpg_sc const auto packet = (jpeg_packet_t *)calloc(1, packet_size); // 4 bytes RTP over TCP header - assert(4 == sizeof(rtp_over_tcp_hdr_t)); packet->rtp_over_tcp_hdr.magic = '$'; // encapsulation packet->rtp_over_tcp_hdr.channel = 0; // number of multiplexed sub-channel on RTPS connection - here the RTP channel packet->rtp_over_tcp_hdr.length = packet_size; - log_v("rtp_over_tcp_hdr_t={.magic=%c,.channel=%i,.length=%i}", packet->rtp_over_tcp_hdr.magic, packet->rtp_over_tcp_hdr.channel, packet->rtp_over_tcp_hdr.length); + log_v("rtp_over_tcp_hdr_t={.magic=%c,.channel=%u,.length=%u}", packet->rtp_over_tcp_hdr.magic, packet->rtp_over_tcp_hdr.channel, packet->rtp_over_tcp_hdr.length); // 12 bytes RTP header - assert(12 == sizeof(rtp_hdr_t)); packet->rtp_hdr.version = 2; packet->rtp_hdr.marker = isLastFragment; packet->rtp_hdr.pt = RTP_PAYLOAD_JPG; packet->rtp_hdr.seq = sequence_number_; packet->rtp_hdr.ts = timestamp; packet->rtp_hdr.ssrc = ssrc_; - log_v("rtp_hdr={.version:%i,.padding:%i,.extension:%i,.cc:%i,.marker:%i,.pt:%i,.seq:%i,.ts:%u,.ssrc:%u}", packet->rtp_hdr.version, packet->rtp_hdr.padding, packet->rtp_hdr.extension, packet->rtp_hdr.cc, packet->rtp_hdr.marker, packet->rtp_hdr.pt, packet->rtp_hdr.seq, packet->rtp_hdr.ts, packet->rtp_hdr.ssrc); + log_v("rtp_hdr={.version:%u,.padding:%u,.extension:%u,.cc:%u,.marker:%u,.pt:%u,.seq:%u,.ts:%u,.ssrc:%u}", packet->rtp_hdr.version, packet->rtp_hdr.padding, packet->rtp_hdr.extension, packet->rtp_hdr.cc, packet->rtp_hdr.marker, packet->rtp_hdr.pt, packet->rtp_hdr.seq, packet->rtp_hdr.ts, packet->rtp_hdr.ssrc); // 8 bytes JPEG payload header - assert(8 == sizeof(jpeg_hdr_t)); packet->jpeg_hdr.tspec = 0; // type-specific field packet->jpeg_hdr.off = (uint32_t)(*jpg_offset - jpg_scan); // fragment byte offset (24 bits in jpg) packet->jpeg_hdr.type = 0; // id of jpeg decoder params packet->jpeg_hdr.q = (uint8_t)(include_quantization_tables ? 0x80 : 0x5e); // quantization factor (or table id) 5eh=94d packet->jpeg_hdr.width = (uint8_t)(width_ >> 3); // frame width in 8 pixel blocks packet->jpeg_hdr.height = (uint8_t)(height_ >> 3); // frame height in 8 pixel blocks - log_v("jpeg_hdr={.tspec:%i,.off:0x%6x,.type:0x2%x,.q:%i,.width:%i.height:%i}", packet->jpeg_hdr.tspec, packet->jpeg_hdr.off, packet->jpeg_hdr.type, packet->jpeg_hdr.q, packet->jpeg_hdr.width, packet->jpeg_hdr.height); - - // length so far should be 24 bytes - assert(24 == sizeof(jpeg_packet_t)); + log_v("jpeg_hdr={.tspec:%u,.off:0x%6x,.type:0x2%x,.q:%u,.width:%u.height:%u}", packet->jpeg_hdr.tspec, packet->jpeg_hdr.off, packet->jpeg_hdr.type, packet->jpeg_hdr.q, packet->jpeg_hdr.width, packet->jpeg_hdr.height); if (include_quantization_tables) { const auto packet_with_quantization = (jpeg_packet_with_quantization_t *)packet; - assert(4 == sizeof(jpeg_hdr_qtable_t)); // Only in first packet of the frame packet_with_quantization->jpeg_hdr_qtable.mbz = 0; packet_with_quantization->jpeg_hdr_qtable.precision = 0; // 8 bit precision packet_with_quantization->jpeg_hdr_qtable.length = jpeg_luminance_table_length + jpeg_chrominance_table_length; - log_v("jpeg_hdr_qtable={.mbz:%i,.precision:%i,.length:%d}", packet_with_quantization->jpeg_hdr_qtable.mbz, packet_with_quantization->jpeg_hdr_qtable.precision, packet_with_quantization->jpeg_hdr_qtable.length); + log_v("jpeg_hdr_qtable={.mbz:%u,.precision:%u,.length:%u}", packet_with_quantization->jpeg_hdr_qtable.mbz, packet_with_quantization->jpeg_hdr_qtable.precision, packet_with_quantization->jpeg_hdr_qtable.length); memcpy(packet_with_quantization->quantization_table_luminance, quantization_table_luminance, jpeg_luminance_table_length); memcpy(packet_with_quantization->quantization_table_chrominance, quantization_table_chrominance, jpeg_chrominance_table_length); // Copy JPG data @@ -85,5 +81,5 @@ rtp_over_tcp_hdr_t *micro_rtsp_streamer::create_jpg_packet(const uint8_t *jpg_sc // Update sequence number sequence_number_++; - return (rtp_over_tcp_hdr_t*)packet; + return (rtp_over_tcp_hdr_t *)packet; } \ No newline at end of file diff --git a/test/test_main.cpp b/test/test_main.cpp index 3cb72e7..f1c75e1 100644 --- a/test/test_main.cpp +++ b/test/test_main.cpp @@ -3,7 +3,9 @@ #include #include + #include +#include static unsigned char jpeg[8468] = { // SOI @@ -65,21 +67,30 @@ void tearDown(void) void test_jpg_decode() { - jpg mr_jpeg; - TEST_ASSERT_TRUE(mr_jpeg.decode(reinterpret_cast(jpeg), sizeof(jpeg))); - TEST_ASSERT_EQUAL_INT32(sizeof(jpeg_data), mr_jpeg.jpeg_data_end - mr_jpeg.jpeg_data_start); - TEST_ASSERT_EQUAL_UINT8_ARRAY(jpeg_data, mr_jpeg.jpeg_data_start, sizeof(jpeg_data)); + jpg jpg; + TEST_ASSERT_TRUE(jpg.decode(reinterpret_cast(jpeg), sizeof(jpeg))); + TEST_ASSERT_EQUAL_INT32(sizeof(jpeg_data), jpg.jpeg_data_end - jpg.jpeg_data_start); + TEST_ASSERT_EQUAL_UINT8_ARRAY(jpeg_data, jpg.jpeg_data_start, sizeof(jpeg_data)); // Id is not stored - TEST_ASSERT_EQUAL_INT32(sizeof(jpg_section_dqt_t::id) + sizeof(jpeg_qtable0), mr_jpeg.quantization_table_luminance_->data_length()); - auto jpg_section_dqt_luminance = reinterpret_cast(mr_jpeg.quantization_table_luminance_->data); + TEST_ASSERT_EQUAL_INT32(sizeof(jpg_section_dqt_t::id) + sizeof(jpeg_qtable0), jpg.quantization_table_luminance_->data_length()); + auto jpg_section_dqt_luminance = reinterpret_cast(jpg.quantization_table_luminance_->data); TEST_ASSERT_EQUAL_UINT8_ARRAY(jpeg_qtable0, jpg_section_dqt_luminance->data, sizeof(jpeg_qtable0)); // Id is not stored - TEST_ASSERT_EQUAL_INT32(sizeof(jpg_section_dqt_t::id) + sizeof(jpeg_qtable1), mr_jpeg.quantization_table_chrominance_->data_length()); - auto jpg_section_dqt_chrominance = reinterpret_cast(mr_jpeg.quantization_table_chrominance_->data); + TEST_ASSERT_EQUAL_INT32(sizeof(jpg_section_dqt_t::id) + sizeof(jpeg_qtable1), jpg.quantization_table_chrominance_->data_length()); + auto jpg_section_dqt_chrominance = reinterpret_cast(jpg.quantization_table_chrominance_->data); TEST_ASSERT_EQUAL_UINT8_ARRAY(jpeg_qtable1, jpg_section_dqt_chrominance->data, sizeof(jpeg_qtable1)); } +void test_struct_sizes() +{ + TEST_ASSERT_EQUAL(4, sizeof(micro_rtsp_streamer::rtp_over_tcp_hdr_t)); +// TEST_ASSERT_EQUAL(12, sizeof(micro_rtsp_streamer::rtp_hdr_t)); +// TEST_ASSERT_EQUAL(8, sizeof(micro_rtsp_streamer::jpeg_hdr_t)); +// TEST_ASSERT_EQUAL(4, sizeof(micro_rtsp_streamer::jpeg_hdr_qtable_t)); +// TEST_ASSERT_EQUAL(24, sizeof(micro_rtsp_streamer::jpeg_packet_t)); +} + void setup() { // Disable brownout @@ -90,6 +101,7 @@ void setup() UNITY_BEGIN(); RUN_TEST(test_jpg_decode); + RUN_TEST(test_struct_sizes); UNITY_END(); }