external-repos/esp32cam-rtsp
1
0
Fork 1
mirror of https://github.com/rzeldent/esp32cam-rtsp.git synced 2025-11-14 20:18:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

WIP

Browse Source
This commit is contained in:
Rene Zeldenthuis
2024-04-01 19:58:44 +02:00
parent f59fb8bb9a
commit 5117f0d21a
9 changed files with 90 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
lib/micro-jpg/src/jpg.cpp
View File

@@ -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;
}

13
lib/micro-rtsp-server/include/micro_rtsp_camera.h
View File

@@ -10,16 +10,15 @@ public:
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_;
};

2
lib/micro-rtsp-server/include/micro_rtsp_requests.h
View File

@@ -18,7 +18,7 @@ private:
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);

18
lib/micro-rtsp-server/include/micro_rtsp_streamer.h
View File

@@ -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_;

20
lib/micro-rtsp-server/src/micro_rtsp_camera.cpp
View File

@@ -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();
}

28
lib/micro-rtsp-server/src/micro_rtsp_requests.cpp
View File

@@ -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)
{

15
lib/micro-rtsp-server/src/micro_rtsp_server.cpp
View File

@@ -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)

22
lib/micro-rtsp-server/src/micro_rtsp_streamer.cpp
View File

@@ -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;
}

28
test/test_main.cpp
View File

@@ -3,7 +3,9 @@
#include <IotWebConf.h>
#include <unity.h>
#include <jpg.h>
#include <micro_rtsp_streamer.h>
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<const uint8_t *>(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<const uint8_t *>(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<const jpg_section_dqt_t *>(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<const jpg_section_dqt_t *>(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<const jpg_section_dqt_t *>(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<const jpg_section_dqt_t *>(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();
}