#include <cstddef>
#include <cstdint>

Include dependency graph for jpeg_reader.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	huffman_table

struct	jpeg_info

struct	jpeg_rtp_data

Enumerations
enum	{ JPEG_MAX_COMPONENT_COUNT = 4 }

enum	huff_type { LUM_DC = 0 , LUM_AC = 1 , CHR_DC = 2 , CHR_AC = 3 }

enum	jpeg_color_spec { JPEG_COLOR_SPEC_NONE = 0 , JPEG_COLOR_SPEC_YCBCR , JPEG_COLOR_SPEC_RGB , JPEG_COLOR_SPEC_CMYK , JPEG_COLOR_SPEC_YCCK }

Functions
bool	jpeg_get_rtp_hdr_data (uint8_t jpeg_data, int len, struct jpeg_rtp_data hdr_data)

int	jpeg_read_info (uint8_t image, int len, struct jpeg_info info)

Variables
const struct huffman_table	default_huffman_tables [4]

Detailed Description

Author: Martin Pulec pulec.nosp@m.@ces.nosp@m.net.c.nosp@m.z

Definition in file jpeg_reader.h.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
JPEG_MAX_COMPONENT_COUNT

Definition at line 58 of file jpeg_reader.h.

     {
        JPEG_MAX_COMPONENT_COUNT = 4,
};

◆ huff_type

enum huff_type

Enumerator
LUM_DC	order of tables in default_huffman_tables
LUM_AC
CHR_DC
CHR_AC

Definition at line 101 of file jpeg_reader.h.

               { 
        LUM_DC = 0,
        LUM_AC = 1,
        CHR_DC = 2,
        CHR_AC = 3,
};

◆ jpeg_color_spec

enum jpeg_color_spec

Enumerator
JPEG_COLOR_SPEC_NONE
JPEG_COLOR_SPEC_YCBCR
JPEG_COLOR_SPEC_RGB
JPEG_COLOR_SPEC_CMYK
JPEG_COLOR_SPEC_YCCK

Definition at line 50 of file jpeg_reader.h.

                     {
        JPEG_COLOR_SPEC_NONE = 0,
        JPEG_COLOR_SPEC_YCBCR,
        JPEG_COLOR_SPEC_RGB,
        JPEG_COLOR_SPEC_CMYK,
        JPEG_COLOR_SPEC_YCCK
};

Function Documentation

◆ jpeg_get_rtp_hdr_data()

bool jpeg_get_rtp_hdr_data	(	uint8_t *	jpeg_data,
		int	len,
		struct jpeg_rtp_data *	hdr_data )

Definition at line 775 of file jpeg_reader.c.

{
        struct jpeg_info i;
        int rc = jpeg_read_info(jpeg_data, len, &i);
 
        if (rc != 0) {
                log_msg(LOG_LEVEL_ERROR, "Cannot parse JPEG!\n");
                return false;
        }
        if (!check_rtp_compatibility(&i)) {
                return false;
        }
 
        hdr_data->width = i.width;
        hdr_data->height = i.height;
        hdr_data->restart_interval = i.restart_interval;
        hdr_data->data = i.data;
        const int a111[] = { 1, 1, 1 },
            a211[] = { 2, 1, 1 },
            a222[] = { 2, 2, 2 };
        if (arr_eq3(i.sampling_factor_v, a111) && arr_eq3(i.sampling_factor_h, a211)) { // 4:2:2
                hdr_data->type = 0;
        } else if (arr_eq3(i.sampling_factor_v, a211) && arr_eq3(i.sampling_factor_h, a211)) { // 4:2:0
                hdr_data->type = 1;
        } else {
                log_msg(LOG_LEVEL_ERROR, "Unsupported JPEG type - sampling horizontal: %d, %d, %d; vertical: %d, %d, %d\n", i.sampling_factor_h[0], i.sampling_factor_h[1], i.sampling_factor_h[2], i.sampling_factor_v[0], i.sampling_factor_v[1], i.sampling_factor_v[2]);
                if (arr_eq3(i.sampling_factor_v, a222) && arr_eq3(i.sampling_factor_h, a211)) {
                        MSG(ERROR, "FFmpeg-generated JPEG 4:2:2 is "
                                   "incompatible with RFC 2435.\n");
                        MSG(WARNING, "Try \"-c lavc:subs=420\"\n");
                }
                return false;
        }
        if (i.restart_interval != 0) {
                hdr_data->type |= 0x40;
        }
 
        hdr_data->q = 255;
        // we try deduce quality from COM marker
        const char *q_str = "quality = ";
        if (strstr(i.com, q_str) && isdigit(*(strstr(i.com, q_str) + strlen(q_str)))) {
                hdr_data->q = atoi(strstr(i.com, q_str) + strlen(q_str));
                assert(hdr_data->q <= 127);
        }
        if (hdr_data->q == 255) {
                hdr_data->quantization_tables[0] =
                    i.quantization_tables[i.comp_table_quantization_map[0]];
                hdr_data->quantization_tables[1] = // shared Cb/Cr table
                    i.quantization_tables[i.comp_table_quantization_map[1]];
        }
 
        return true;
}

References arr_eq3(), check_rtp_compatibility(), jpeg_info::com, jpeg_info::comp_table_quantization_map, jpeg_info::data, jpeg_rtp_data::data, jpeg_info::height, jpeg_rtp_data::height, jpeg_read_info(), len, LOG_LEVEL_ERROR, log_msg(), MSG, jpeg_rtp_data::q, jpeg_info::quantization_tables, jpeg_rtp_data::quantization_tables, jpeg_info::restart_interval, jpeg_rtp_data::restart_interval, jpeg_info::sampling_factor_h, jpeg_info::sampling_factor_v, jpeg_rtp_data::type, jpeg_info::width, and jpeg_rtp_data::width.

Referenced by tx_send_jpeg().

Here is the call graph for this function:

◆ jpeg_read_info()

int jpeg_read_info	(	uint8_t *	image,
		int	len,
		struct jpeg_info *	info )

This function reads values from JPEG file.

Return values

0	ok
-1	general error
-2	incomplete file (required markers missing)

Definition at line 551 of file jpeg_reader.c.

{
        uint8_t *image_start = image;
 
        // Check first SOI marker
        int marker_soi = read_marker(&image);
        if (marker_soi != JPEG_MARKER_SOI) {
                log_msg(LOG_LEVEL_ERROR, "[JPEG] [Error] JPEG data should begin with SOI marker, but marker %s was found!\n", jpeg_marker_name((enum jpeg_marker_code)marker_soi));
                return -1;
        }
 
        info->huff_lum_dc[0] = 255;
        info->huff_lum_ac[0] = 255;
        info->huff_chm_dc[0] = 255;
        info->huff_chm_ac[0] = 255;
        info->comp_count = 0;
        info->interleaved = true;
        info->restart_interval = 0; // if DRI is not present
        info->com[0] = '\0'; // if COM is not present
        info->color_spec = JPEG_COLOR_SPEC_YCBCR; // default
        bool marker_present[255] = { 0 };
 
        // currently reading up to SOS marker gives us all needed data
        while (!marker_present[JPEG_MARKER_EOI] && !marker_present[JPEG_MARKER_SOS]
                        && image < image_start + len) {
                // Read marker
                int marker = read_marker(&image);
                if ( marker == 0) { // not a marker (byte stuffing)
                        continue;
                }
                if (marker == -1) {
                        log_msg(LOG_LEVEL_WARNING, "Unknown marker!\n");
                        continue;
                }
                if (marker == 0xff) { // first byte might have been padding and the second byte marker start
                        image--;
                        continue;
                }
 
                marker_present[marker] = true;
                int rc;
 
                // Read more info according to the marker
                switch (marker)
                {
                        case JPEG_MARKER_SOF0: // Baseline
                                if ((rc = read_sof0(info, &image)) != 0) {
                                        log_msg(LOG_LEVEL_ERROR, "Error reading SOF0!\n");
                                        return rc;
                                }
                                break;
 
                        case JPEG_MARKER_DHT:
                                if ((rc = read_dht(info, &image)) != 0) {
                                        log_msg(LOG_LEVEL_ERROR, "Error reading DQT!\n");
                                        return rc;
                                }
                                break;
 
                        case JPEG_MARKER_DQT:
                                if ((rc = read_dqt(info, &image)) != 0) {
                                        log_msg(LOG_LEVEL_ERROR, "Error reading DQT!\n");
                                        return rc;
                                }
                                break;
 
                        case JPEG_MARKER_DRI:
                                if ((rc = read_dri(info, &image)) != 0) {
                                        log_msg(LOG_LEVEL_ERROR, "Error reading DRI!\n");
                                        return rc;
                                }
                                break;
 
                        case JPEG_MARKER_COM:
                                if ((rc = read_com(info, &image)) != 0) {
                                        log_msg(LOG_LEVEL_ERROR, "Error reading COM!\n");
                                        return rc;
                                }
                                break;
 
                        case JPEG_MARKER_APP14:
                                if ((rc = read_adobe_app14(info, &image)) != 0) {
                                        log_msg(LOG_LEVEL_ERROR, "Error reading APP14!\n");
                                        return rc;
                                }
                                break;
 
                        case JPEG_MARKER_SOS:
                                if ((rc = read_sos(info, &image)) != 0) {
                                        log_msg(LOG_LEVEL_ERROR, "Error reading SOS!\n");
                                        return rc;
                                }
                                break;
 
                        case JPEG_MARKER_EOI:
                                break;
 
                        // included because these fixed-sized markers do not contain lenght field
                        // thus skipping in default branch will misbehave
                        case JPEG_MARKER_RST0:
                        case JPEG_MARKER_RST1:
                        case JPEG_MARKER_RST2:
                        case JPEG_MARKER_RST3:
                        case JPEG_MARKER_RST4:
                        case JPEG_MARKER_RST5:
                        case JPEG_MARKER_RST6:
                        case JPEG_MARKER_RST7:
                                break;
 
                        default:
                                skip_marker_content(&image);
                                break;
                }
        }
 
        enum jpeg_marker_code req_markers[] = { JPEG_MARKER_SOF0, JPEG_MARKER_DQT, JPEG_MARKER_SOS };
        for (unsigned int i = 0; i < sizeof req_markers / sizeof req_markers[0]; ++i) {
                if (!marker_present[req_markers[i]]) {
                        log_msg(LOG_LEVEL_ERROR, "Marker \"%s\" missing in JPEG file!\n",
                                        jpeg_marker_name(req_markers[i]));
                        if (req_markers[i] == JPEG_MARKER_SOF0) {
                                log_msg(LOG_LEVEL_INFO, "Perhaps unsupported JPEG type.\n");
                        }
                        return -2;
                }
        }
 
        // APP14 doesn't distinguis between CMYK and RGB thus we deduce from comp count
        if (info->color_spec == JPEG_COLOR_SPEC_CMYK && info->comp_count == 3) {
                info->color_spec = JPEG_COLOR_SPEC_RGB;
        }
 
        return 0;
}

References JPEG_COLOR_SPEC_CMYK, JPEG_COLOR_SPEC_RGB, JPEG_COLOR_SPEC_YCBCR, JPEG_MARKER_APP14, JPEG_MARKER_COM, JPEG_MARKER_DHT, JPEG_MARKER_DQT, JPEG_MARKER_DRI, JPEG_MARKER_EOI, jpeg_marker_name(), JPEG_MARKER_RST0, JPEG_MARKER_RST1, JPEG_MARKER_RST2, JPEG_MARKER_RST3, JPEG_MARKER_RST4, JPEG_MARKER_RST5, JPEG_MARKER_RST6, JPEG_MARKER_RST7, JPEG_MARKER_SOF0, JPEG_MARKER_SOI, JPEG_MARKER_SOS, len, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, log_msg(), read_adobe_app14(), read_com(), read_dht(), read_dqt(), read_dri(), read_marker(), read_sof0(), read_sos(), and skip_marker_content().

Referenced by jpeg_get_rtp_hdr_data().

Here is the call graph for this function:

Variable Documentation

◆ default_huffman_tables

const struct huffman_table default_huffman_tables[4]

extern

Definition at line 125 of file jpeg_reader.c.

                                                       {
        { lum_dc_codelens, lum_dc_symbols },
        { lum_ac_codelens, lum_ac_symbols },
        { chm_dc_codelens, chm_dc_symbols },
        { chm_ac_codelens, chm_ac_symbols },
};

Referenced by jpeg_writer_write_dhts().

Classes

Enumerations

Functions

Variables