mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-10 03:19:40 +00:00
Code Issues 1 Projects Releases Wiki Activity

codecparsers: jpeg: tweak parser API.

Browse source 
... to allow for more consistent parsing API among various codec parsers.
In particular, drop use of GList.
This commit is contained in:
Gwenole Beauchesne 2012-07-16 17:35:19 +02:00
parent c7587e87dd
commit 8f93bbc937
2 changed files with 469 additions and 486 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

561
gst-libs/gst/codecparsers/gstjpegparser.c
View file

@ -1,7 +1,7 @@
/*
* gstjpegparser.c - JPEG parser for baseline
* gstjpegparser.c - JPEG parser
*
* Copyright (C) 2011 Intel Corporation
* Copyright (C) 2011-2012 Intel Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
@ -19,10 +19,9 @@
* Boston, MA 02110-1301 USA
*/
#include "gstjpegparser.h"
#include <string.h>
#include <gst/base/gstbytereader.h>
#include "gstjpegparser.h"
#ifndef GST_DISABLE_GST_DEBUG
@ -52,19 +51,6 @@ ensure_debug_category (void)
#define DEBUG_PRINT_COMMENT 0
#define CHECK_FAILED(exp, ret) G_STMT_START { \
if (!(exp)) { \
result = ret; \
goto wrong_state; \
} \
} G_STMT_END
#define JPEG_RESULT_CHECK(result) G_STMT_START { \
if ((result) != GST_JPEG_PARSER_OK) { \
goto wrong_state; \
} \
} G_STMT_END
#define READ_UINT8(reader, val) G_STMT_START { \
if (!gst_byte_reader_get_uint8 ((reader), &(val))) { \
GST_WARNING ("failed to read uint8"); \
@ -97,13 +83,10 @@ ensure_debug_category (void)
} G_STMT_END
static gboolean jpeg_parse_to_next_marker (GstByteReader * reader,
guint8 * marker);
/* CCITT T.81, Annex K.1 Quantization tables for luminance and chrominance components */
/* only for 8-bit per sample image */
static const GstJpegQuantTables
default_quant_tables_zigzag = {
/* *INDENT-OFF* */
static const GstJpegQuantTables default_quant_tables_zigzag = {
.quant_tables = {
/* luma */
{0, {0x10, 0x0b, 0x0c, 0x0e, 0x0c, 0x0a, 0x10, 0x0e,
@ -135,38 +118,32 @@ default_quant_tables_zigzag = {
{0,}
}
};
/* *INDENT-ON* */
/* Table K.3: typical Huffman tables for 8-bit precision luminance and chrominance */
/*
0..GST_JPEG_MAX_SCAN_COMPONENTS -1, DC huffman tables
GST_JPEG_MAX_SCAN_COMPONENTS...GST_JPEG_MAX_SCAN_COMPONENTS*2-1, AC huffman tables
*/
static const
GstJpegHuffmanTables default_huf_tables = {
/* *INDENT-OFF* */
static const GstJpegHuffmanTables default_huf_tables = {
.dc_tables = {
/* DC luma */
{{0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b},
TRUE
},
TRUE},
/* DC chroma */
{{0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b},
TRUE
},
TRUE},
/* DC chroma */
{{0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b},
TRUE
},
{ { 0x0 },
{ 0x0 }
TRUE},
{{0x0,},
{0x0,}
}
},
.ac_tables = {
@ -194,8 +171,7 @@ GstJpegHuffmanTables default_huf_tables = {
0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
0xf9, 0xfa},
TRUE
},
TRUE},
/* AC chroma */
{{0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04,
0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77},
@ -220,8 +196,7 @@ GstJpegHuffmanTables default_huf_tables = {
0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
0xf9, 0xfa},
TRUE
},
TRUE},
/* AC chroma */
{{0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04,
0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77},
@ -246,205 +221,246 @@ GstJpegHuffmanTables default_huf_tables = {
0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
0xf9, 0xfa},
TRUE
},
{ { 0x00 },
{ 0x00 }
TRUE},
{{0x00,},
{0x00,}
}
}
};
/* *INDENT-ON* */
static gboolean
jpeg_parse_to_next_marker (GstByteReader * reader, guint8 * marker)
static inline gboolean
jpeg_parse_to_next_marker (GstByteReader * br, guint8 * marker)
{
guint8 value;
gint ofs;
while (gst_byte_reader_get_uint8 (reader, &value)) {
if (value != 0xFF)
continue;
while (value == 0xFF) {
READ_UINT8 (reader, value);
}
if (value == 0x00)
continue;
*marker = value;
ofs = gst_jpeg_scan_for_marker_code (br->data, br->size, br->byte);
if (ofs < 0)
return FALSE;
if (marker)
*marker = br->data[ofs + 1];
gst_byte_reader_skip (br, ofs - br->byte + 2);
return TRUE;
}
gint
gst_jpeg_scan_for_marker_code (const guint8 * data, gsize size, guint offset)
{
guint i;
g_return_val_if_fail (data != NULL, -1);
g_return_val_if_fail (size > offset, -1);
for (i = offset; i < size - 1;) {
if (data[i] != 0xff)
i++;
else {
const guint8 v = data[i + 1];
if (v >= 0xc0 && v <= 0xfe)
return i;
i += 2;
}
}
return -1;
}
gboolean
gst_jpeg_parse_frame_hdr (GstJpegFrameHdr * frame_hdr,
const guint8 * data, gsize size, guint offset)
{
GstByteReader br;
guint16 length;
guint8 val;
guint i;
g_return_val_if_fail (frame_hdr != NULL, FALSE);
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (size > offset, FALSE);
size -= offset;
gst_byte_reader_init (&br, &data[offset], size);
g_return_val_if_fail (size >= 8, FALSE);
U_READ_UINT16 (&br, length); /* Lf */
g_return_val_if_fail (size >= length, FALSE);
U_READ_UINT8 (&br, frame_hdr->sample_precision);
U_READ_UINT16 (&br, frame_hdr->height);
U_READ_UINT16 (&br, frame_hdr->width);
U_READ_UINT8 (&br, frame_hdr->num_components);
g_return_val_if_fail (frame_hdr->num_components <=
GST_JPEG_MAX_SCAN_COMPONENTS, FALSE);
length -= 8;
g_return_val_if_fail (length >= 3 * frame_hdr->num_components, FALSE);
for (i = 0; i < frame_hdr->num_components; i++) {
U_READ_UINT8 (&br, frame_hdr->components[i].identifier);
U_READ_UINT8 (&br, val);
frame_hdr->components[i].horizontal_factor = (val >> 4) & 0x0F;
frame_hdr->components[i].vertical_factor = (val & 0x0F);
U_READ_UINT8 (&br, frame_hdr->components[i].quant_table_selector);
g_return_val_if_fail ((frame_hdr->components[i].horizontal_factor <= 4 &&
frame_hdr->components[i].vertical_factor <= 4 &&
frame_hdr->components[i].quant_table_selector < 4), FALSE);
length -= 3;
}
g_assert (length == 0);
return TRUE;
}
gboolean
gst_jpeg_parse_scan_hdr (GstJpegScanHdr * scan_hdr,
const guint8 * data, gsize size, guint offset)
{
GstByteReader br;
guint16 length;
guint8 val;
guint i;
g_return_val_if_fail (scan_hdr != NULL, FALSE);
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (size > offset, FALSE);
size -= offset;
gst_byte_reader_init (&br, &data[offset], size);
g_return_val_if_fail (size >= 3, FALSE);
U_READ_UINT16 (&br, length); /* Ls */
g_return_val_if_fail (size >= length, FALSE);
U_READ_UINT8 (&br, scan_hdr->num_components);
g_return_val_if_fail (scan_hdr->num_components <=
GST_JPEG_MAX_SCAN_COMPONENTS, FALSE);
length -= 3;
g_return_val_if_fail (length >= 2 * scan_hdr->num_components, FALSE);
for (i = 0; i < scan_hdr->num_components; i++) {
U_READ_UINT8 (&br, scan_hdr->components[i].component_selector);
U_READ_UINT8 (&br, val);
scan_hdr->components[i].dc_selector = (val >> 4) & 0x0F;
scan_hdr->components[i].ac_selector = val & 0x0F;
g_return_val_if_fail ((scan_hdr->components[i].dc_selector < 4 &&
scan_hdr->components[i].ac_selector < 4), FALSE);
length -= 2;
}
/* FIXME: Ss, Se, Ah, Al */
g_assert (length == 3);
return TRUE;
}
gboolean
gst_jpeg_parse_huffman_table (GstJpegHuffmanTables * huf_tables,
const guint8 * data, gsize size, guint offset)
{
GstByteReader br;
GstJpegHuffmanTable *huf_table;
guint16 length;
guint8 val, table_class, table_index;
guint32 value_count;
guint i;
g_return_val_if_fail (huf_tables != NULL, FALSE);
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (size > offset, FALSE);
size -= offset;
gst_byte_reader_init (&br, &data[offset], size);
g_return_val_if_fail (size >= 2, FALSE);
U_READ_UINT16 (&br, length); /* Lh */
g_return_val_if_fail (size >= length, FALSE);
while (gst_byte_reader_get_remaining (&br)) {
U_READ_UINT8 (&br, val);
table_class = ((val >> 4) & 0x0F);
table_index = (val & 0x0F);
g_return_val_if_fail (table_index < GST_JPEG_MAX_SCAN_COMPONENTS, FALSE);
if (table_class == 0) {
huf_table = &huf_tables->dc_tables[table_index];
} else {
huf_table = &huf_tables->ac_tables[table_index];
}
READ_BYTES (&br, huf_table->huf_bits, 16);
value_count = 0;
for (i = 0; i < 16; i++)
value_count += huf_table->huf_bits[i];
READ_BYTES (&br, huf_table->huf_values, value_count);
huf_table->valid = TRUE;
}
return TRUE;
failed:
return FALSE;
}
GstJpegParserResult
gst_jpeg_parse_frame_hdr (GstJpegFrameHdr * frame_hdr,
gboolean
gst_jpeg_parse_quant_table (GstJpegQuantTables * quant_tables,
const guint8 * data, gsize size, guint offset)
{
GstByteReader bytes_reader = GST_BYTE_READER_INIT (data + offset, size - offset);
GstJpegParserResult result = GST_JPEG_PARSER_OK;
guint8 val;
u_int i;
g_assert (frame_hdr && data && size);
CHECK_FAILED (gst_byte_reader_get_remaining (&bytes_reader) >= 6, GST_JPEG_PARSER_ERROR);
U_READ_UINT8 (&bytes_reader, frame_hdr->sample_precision);
U_READ_UINT16 (&bytes_reader, frame_hdr->height);
U_READ_UINT16 (&bytes_reader, frame_hdr->width);
U_READ_UINT8 (&bytes_reader, frame_hdr->num_components);
CHECK_FAILED (frame_hdr->num_components <= GST_JPEG_MAX_SCAN_COMPONENTS,
GST_JPEG_PARSER_ERROR);
CHECK_FAILED (gst_byte_reader_get_remaining(&bytes_reader) >= 3*frame_hdr->num_components,
GST_JPEG_PARSER_ERROR);
for (i = 0; i < frame_hdr->num_components; i++) {
U_READ_UINT8 (&bytes_reader, frame_hdr->components[i].identifier);
U_READ_UINT8 (&bytes_reader, val);
frame_hdr->components[i].horizontal_factor = (val >> 4) & 0x0F;
frame_hdr->components[i].vertical_factor = (val & 0x0F);
U_READ_UINT8 (&bytes_reader, frame_hdr->components[i].quant_table_selector);
CHECK_FAILED ((frame_hdr->components[i].horizontal_factor <= 4 &&
frame_hdr->components[i].vertical_factor <= 4 &&
frame_hdr->components[i].quant_table_selector < 4),
GST_JPEG_PARSER_ERROR);
}
return GST_JPEG_PARSER_OK;
wrong_state:
return result;
}
GstJpegParserResult
gst_jpeg_parse_scan_hdr (GstJpegScanHdr * scan_hdr,
const guint8 * data, gsize size, guint offset)
{
GstByteReader bytes_reader = GST_BYTE_READER_INIT (data + offset, size - offset);
GstJpegParserResult result = GST_JPEG_PARSER_OK;
guint8 val;
u_int i;
g_assert (scan_hdr && data && size);
READ_UINT8 (&bytes_reader, scan_hdr->num_components);
CHECK_FAILED (scan_hdr->num_components <= GST_JPEG_MAX_SCAN_COMPONENTS,
GST_JPEG_PARSER_BROKEN_DATA);
CHECK_FAILED (gst_byte_reader_get_remaining (&bytes_reader) >= 2*scan_hdr->num_components,
GST_JPEG_PARSER_ERROR);
for (i = 0; i < scan_hdr->num_components; i++) {
U_READ_UINT8 (&bytes_reader,
scan_hdr->components[i].component_selector);
U_READ_UINT8 (&bytes_reader, val);
scan_hdr->components[i].dc_selector = (val >> 4) & 0x0F;
scan_hdr->components[i].ac_selector = val & 0x0F;
g_assert (scan_hdr->components[i].dc_selector < 4 &&
scan_hdr->components[i].ac_selector < 4);
CHECK_FAILED ((scan_hdr->components[i].dc_selector < 4 &&
scan_hdr->components[i].ac_selector < 4),
GST_JPEG_PARSER_BROKEN_DATA);
}
return GST_JPEG_PARSER_OK;
failed:
return GST_JPEG_PARSER_ERROR;
wrong_state:
return result;
}
GstJpegParserResult
gst_jpeg_parse_huffman_table (
GstJpegHuffmanTables *huf_tables,
const guint8 * data, gsize size, guint offset)
{
GstByteReader bytes_reader = GST_BYTE_READER_INIT (data+offset, size-offset);
GstJpegParserResult result = GST_JPEG_PARSER_OK;
GstJpegHuffmanTable * huf_table;
guint8 tmp_val;
gboolean is_dc;
guint8 table_index;
guint32 value_count;
u_int i;
g_assert (huf_tables && data && size);
while (gst_byte_reader_get_remaining (&bytes_reader)) {
U_READ_UINT8 (&bytes_reader, tmp_val);
is_dc = !((tmp_val >> 4) & 0x0F);
table_index = (tmp_val & 0x0F);
CHECK_FAILED (table_index < GST_JPEG_MAX_SCAN_COMPONENTS,
GST_JPEG_PARSER_BROKEN_DATA);
if (is_dc) {
huf_table = &huf_tables->dc_tables[table_index];
} else {
huf_table = &huf_tables->ac_tables[table_index];
}
READ_BYTES (&bytes_reader, huf_table->huf_bits, 16);
value_count = 0;
for (i = 0; i < 16; i++)
value_count += huf_table->huf_bits[i];
READ_BYTES (&bytes_reader, huf_table->huf_values, value_count);
huf_table->valid = TRUE;
}
return GST_JPEG_PARSER_OK;
failed:
return GST_JPEG_PARSER_ERROR;
wrong_state:
return result;
}
GstJpegParserResult
gst_jpeg_parse_quant_table (
GstJpegQuantTables *quant_tables,
const guint8 * data, gsize size, guint offset)
{
GstByteReader bytes_reader = GST_BYTE_READER_INIT (data + offset, size - offset);
GstJpegParserResult result = GST_JPEG_PARSER_OK;
GstByteReader br;
GstJpegQuantTable *quant_table;
guint8 val;
guint8 table_index;
guint16 length;
guint8 val, table_index;
guint i;
g_assert (quant_tables && data && size);
while (gst_byte_reader_get_remaining (&bytes_reader)) {
U_READ_UINT8 (&bytes_reader, val);
g_return_val_if_fail (quant_tables != NULL, FALSE);
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (size > offset, FALSE);
size -= offset;
gst_byte_reader_init (&br, &data[offset], size);
g_return_val_if_fail (size >= 2, FALSE);
U_READ_UINT16 (&br, length); /* Lq */
g_return_val_if_fail (size >= length, FALSE);
while (gst_byte_reader_get_remaining (&br)) {
U_READ_UINT8 (&br, val);
table_index = (val & 0x0f);
CHECK_FAILED (table_index < GST_JPEG_MAX_SCAN_COMPONENTS,
GST_JPEG_PARSER_BROKEN_DATA);
g_return_val_if_fail (table_index < GST_JPEG_MAX_SCAN_COMPONENTS, FALSE);
quant_table = &quant_tables->quant_tables[table_index];
quant_table->quant_precision = ((val >> 4) & 0x0f);
CHECK_FAILED (gst_byte_reader_get_remaining(&bytes_reader) >= GST_JPEG_MAX_QUANT_ELEMENTS * (1 + !!quant_table->quant_precision),
GST_JPEG_PARSER_BROKEN_DATA);
g_return_val_if_fail (gst_byte_reader_get_remaining (&br) >=
GST_JPEG_MAX_QUANT_ELEMENTS * (1 + ! !quant_table->quant_precision),
FALSE);
for (i = 0; i < GST_JPEG_MAX_QUANT_ELEMENTS; i++) {
if (!quant_table->quant_precision) { /* 8-bit values */
U_READ_UINT8 (&bytes_reader, val);
U_READ_UINT8 (&br, val);
quant_table->quant_table[i] = val;
} else { /* 16-bit values */
U_READ_UINT16 (&bytes_reader, quant_table->quant_table[i]);
U_READ_UINT16 (&br, quant_table->quant_table[i]);
}
}
quant_table->valid = TRUE;
}
return GST_JPEG_PARSER_OK;
wrong_state:
return result;
return TRUE;
}
GstJpegParserResult
gboolean
gst_jpeg_parse_restart_interval (guint * interval,
const guint8 * data, gsize size, guint offset)
{
GstByteReader bytes_reader = GST_BYTE_READER_INIT (data + offset, size - offset);
guint16 tmp;
GstByteReader br;
guint16 length, val;
g_assert (interval && data && size);
READ_UINT16 (&bytes_reader, tmp);
*interval = tmp;
return GST_JPEG_PARSER_OK;
g_return_val_if_fail (interval != NULL, FALSE);
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (size > offset, FALSE);
failed:
return GST_JPEG_PARSER_BROKEN_DATA;
size -= offset;
gst_byte_reader_init (&br, &data[offset], size);
g_return_val_if_fail (size >= 4, FALSE);
U_READ_UINT16 (&br, length); /* Lr */
g_return_val_if_fail (size >= length, FALSE);
U_READ_UINT16 (&br, val);
*interval = val;
return TRUE;
}
void
@ -452,109 +468,88 @@ gst_jpeg_get_default_huffman_tables (GstJpegHuffmanTables *huf_tables)
{
g_assert (huf_tables);
memcpy (huf_tables, &default_huf_tables, sizeof (GstJpegHuffmanTables));
memcpy (huf_tables, &default_huf_tables, sizeof (*huf_tables));
}
void
gst_jpeg_get_default_quantization_tables (GstJpegQuantTables * quant_tables)
{
g_assert (quant_tables);
memcpy (quant_tables, &default_quant_tables_zigzag, sizeof (GstJpegQuantTables));
memcpy (quant_tables, &default_quant_tables_zigzag, sizeof (*quant_tables));
}
static gint32
jpeg_scan_to_end (const guint8 *start, guint32 size)
gboolean
gst_jpeg_parse (GstJpegMarkerSegment * seg,
const guint8 * data, gsize size, guint offset)
{
const guint8 *pos = start, *end = start + size;
GstByteReader br;
guint16 length;
for (; pos < end; ++pos) {
if (*pos != 0xFF)
continue;
while (*pos == 0xFF && pos + 1 < end)
++pos;
if (*pos == 0x00 || *pos == 0xFF ||
(*pos >= GST_JPEG_MARKER_RST_MIN && *pos <= GST_JPEG_MARKER_RST_MAX))
continue;
break;
g_return_val_if_fail (seg != NULL, FALSE);
if (size <= offset) {
GST_DEBUG ("failed to parse from offset %u, buffer is too small", offset);
return FALSE;
}
if (pos >= end)
return size;
return pos - start - 1;
}
static GstJpegTypeOffsetSize *
gst_jpeg_segment_new (guint8 marker, guint offset, gint size)
{
GstJpegTypeOffsetSize *seg;
if (GST_JPEG_MARKER_SOS == marker)
seg = g_malloc0 (sizeof (GstJpegScanOffsetSize));
else
seg = g_malloc0 (sizeof (GstJpegTypeOffsetSize));
seg->type = marker;
seg->offset = offset;
seg->size = size;
return seg;
}
GList *
gst_jpeg_parse(const guint8 * data, gsize size, guint offset)
{
GstByteReader bytes_reader;
guint8 marker;
guint16 header_length;
GList *segments = NULL;
GstJpegTypeOffsetSize *seg;
const guint8 *scan_start;
gint scan_size = 0;
size -= offset;
gst_byte_reader_init (&br, &data[offset], size);
if ((gssize)size <= 0) {
GST_DEBUG ("Can't parse from offset %d, buffer is too small", offset);
return NULL;
if (!jpeg_parse_to_next_marker (&br, &seg->marker)) {
GST_DEBUG ("failed to find marker code");
return FALSE;
}
gst_byte_reader_init (&bytes_reader, &data[offset], size);
seg->offset = offset + gst_byte_reader_get_pos (&br);
seg->size = -1;
/* read SOI */
if (!jpeg_parse_to_next_marker (&bytes_reader, &marker) ||
marker != GST_JPEG_MARKER_SOI)
goto failed;
while (jpeg_parse_to_next_marker (&bytes_reader, &marker)) {
if (marker == GST_JPEG_MARKER_EOI)
/* Try to find end of segment */
switch (seg->marker) {
case GST_JPEG_MARKER_SOI:
case GST_JPEG_MARKER_EOI:
fixed_size_segment:
seg->size = 2;
break;
READ_UINT16 (&bytes_reader, header_length);
if (header_length < 2 ||
gst_byte_reader_get_remaining (&bytes_reader) < header_length - 2)
goto failed;
seg = gst_jpeg_segment_new (marker,
gst_byte_reader_get_pos(&bytes_reader) + offset,
header_length - 2);
segments = g_list_prepend(segments, seg);
gst_byte_reader_skip (&bytes_reader, header_length - 2);
if (seg->type == GST_JPEG_MARKER_SOS) {
GstJpegScanOffsetSize * const scan_seg = (GstJpegScanOffsetSize *)seg;
scan_start = gst_byte_reader_peek_data_unchecked (&bytes_reader);
scan_size = jpeg_scan_to_end (scan_start,
gst_byte_reader_get_remaining (&bytes_reader));
if (scan_size <= 0)
case (GST_JPEG_MARKER_SOF_MIN + 0): /* Lf */
case (GST_JPEG_MARKER_SOF_MIN + 1): /* Lf */
case (GST_JPEG_MARKER_SOF_MIN + 2): /* Lf */
case (GST_JPEG_MARKER_SOF_MIN + 3): /* Lf */
case (GST_JPEG_MARKER_SOF_MIN + 9): /* Lf */
case (GST_JPEG_MARKER_SOF_MIN + 10): /* Lf */
case (GST_JPEG_MARKER_SOF_MIN + 11): /* Lf */
case GST_JPEG_MARKER_SOS: /* Ls */
case GST_JPEG_MARKER_DQT: /* Lq */
case GST_JPEG_MARKER_DHT: /* Lh */
case GST_JPEG_MARKER_DAC: /* La */
case GST_JPEG_MARKER_DRI: /* Lr */
case GST_JPEG_MARKER_COM: /* Lc */
case GST_JPEG_MARKER_DNL: /* Ld */
variable_size_segment:
READ_UINT16 (&br, length);
seg->size = length;
break;
scan_seg->data_offset = gst_byte_reader_get_pos (&bytes_reader) + offset;
scan_seg->data_size = scan_size;
gst_byte_reader_skip (&bytes_reader, scan_size);
default:
/* Application data segment length (Lp) */
if (seg->marker >= GST_JPEG_MARKER_APP_MIN &&
seg->marker <= GST_JPEG_MARKER_APP_MAX)
goto variable_size_segment;
/* Restart markers (fixed size, two bytes only) */
if (seg->marker >= GST_JPEG_MARKER_RST_MIN &&
seg->marker <= GST_JPEG_MARKER_RST_MAX)
goto fixed_size_segment;
/* Fallback: scan for next marker */
if (!jpeg_parse_to_next_marker (&br, NULL))
goto failed;
seg->size = gst_byte_reader_get_pos (&br) - seg->offset;
break;
}
}
return g_list_reverse (segments);
return TRUE;
failed:
{
GST_WARNING ("Failed to parse");
return g_list_reverse (segments);
}
return FALSE;
}

110
gst-libs/gst/codecparsers/gstjpegparser.h
View file

@ -1,7 +1,7 @@
/*
* gstjpegparser.h - JPEG parser
*
* Copyright (C) 2011 Intel Corporation
* Copyright (C) 2011-2012 Intel Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
@ -60,25 +60,7 @@ typedef struct _GstJpegScanComponent GstJpegScanComponent;
typedef struct _GstJpegScanHdr GstJpegScanHdr;
typedef struct _GstJpegFrameComponent GstJpegFrameComponent;
typedef struct _GstJpegFrameHdr GstJpegFrameHdr;
typedef struct _GstJpegTypeOffsetSize GstJpegTypeOffsetSize;
typedef struct _GstJpegScanOffsetSize GstJpegScanOffsetSize;
/**
* GstJpegParserResult:
* @GST_JPEG_PARSER_OK: The parsing succeeded
* @GST_JPEG_PARSER_BROKEN_DATA: The data to parse is broken
* @GST_JPEG_PARSER_NO_SCAN_FOUND: No scan found during the parsing
* @GST_JPEG_PARSER_ERROR: An error occured while parsing
*
* The result of parsing JPEG data.
*/
typedef enum
{
GST_JPEG_PARSER_OK,
GST_JPEG_PARSER_BROKEN_DATA,
GST_JPEG_PARSER_NO_SCAN_FOUND,
GST_JPEG_PARSER_ERROR,
} GstJpegParserResult;
typedef struct _GstJpegMarkerSegment GstJpegMarkerSegment;
/**
* GstJpegMarkerCode:
@ -124,7 +106,6 @@ typedef enum {
* @GST_JPEG_PROFILE_EXTENDED: Extended sequential DCT
* @GST_JPEG_PROFILE_PROGRESSIVE: Progressive DCT
* @GST_JPEG_PROFILE_LOSSLESS: Lossless (sequential)
* @GST_JPEG_PROFILE_ARITHMETIC: Flag for arithmetic coding
*
* JPEG encoding processes.
*/
@ -133,9 +114,20 @@ typedef enum {
GST_JPEG_PROFILE_EXTENDED = 0x01,
GST_JPEG_PROFILE_PROGRESSIVE = 0x02,
GST_JPEG_PROFILE_LOSSLESS = 0x03,
GST_JPEG_PROFILE_ARITHMETIC = 0x80
} GstJpegProfile;
/**
* GstJpegEntropyCodingMode:
* @GST_JPEG_ENTROPY_CODING_HUFFMAN: Huffman coding
* @GST_JPEG_ENTROPY_CODING_ARITHMETIC: arithmetic coding
*
* JPEG entropy coding mode.
*/
typedef enum {
GST_JPEG_ENTROPY_CODING_HUFFMAN = 0x00,
GST_JPEG_ENTROPY_CODING_ARITHMETIC = 0x08
} GstJpegEntropyCodingMode;
/**
* GstJpegQuantTable:
* @quant_precision: Quantization table element precision (Pq)
@ -241,7 +233,6 @@ struct _GstJpegFrameComponent
/**
* GstJpegFrameHdr:
* @profile: JPEG encoding process (see #GstJpegProfile)
* @sample_precision: Sample precision (P)
* @height: Number of lines (Y)
* @width: Number of samples per line (X)
@ -253,7 +244,6 @@ struct _GstJpegFrameComponent
*/
struct _GstJpegFrameHdr
{
guint8 profile;
guint8 sample_precision; /* 2 .. 16 */
guint16 width; /* 1 .. 65535 */
guint16 height; /* 0 .. 65535 */
@ -262,38 +252,37 @@ struct _GstJpegFrameHdr
};
/**
* GstJpegTypeOffsetSize:
* GstJpegMarkerSegment:
* @type: The type of the segment that starts at @offset
* @offset: The offset to the segment start in bytes
* @size: The size in bytes of the segment, or -1 if the end was not found
* @offset: The offset to the segment start in bytes. This is the
* exact start of the segment, no marker code included
* @size: The size in bytes of the segment, or -1 if the end was not
* found. It is the exact size of the segment, no marker code included
*
* A structure that contains the type of a segment, its offset and its size.
*/
struct _GstJpegTypeOffsetSize
struct _GstJpegMarkerSegment
{
guint8 type;
guint8 marker;
guint offset;
gint size;
};
/**
* GstJpegScanOffsetSize:
* @header: The header info associated to the scan
* @data_offset: The offset to the first entropy-coded segment in bytes
* @data_size: The size in bytes of the scan data, including all ECS
* and RST segments, or -1 if the end was not found
* gst_jpeg_scan_for_marker_code:
* @data: The data to parse
* @size: The size of @data
* @offset: The offset from which to start parsing
*
* A structure that contains information on a scan. A scan comprises of the
* scan @header, and all entropy-coded segment (ECS) and restart marker (RST)
* associated to it. The header type MUST be set to @GST_JPEG_MARKER_SOS.
* Scans the JPEG bitstream contained in @data for the next marker
* code. If found, the function returns an offset to the marker code,
* including the 0xff prefix code but excluding any extra fill bytes.
*
* Returns: offset to the marker code if found, or -1 if not found.
*/
struct _GstJpegScanOffsetSize
{
GstJpegTypeOffsetSize header;
guint data_offset;
gint data_size;
};
gint gst_jpeg_scan_for_marker_code (const guint8 * data,
gsize size,
guint offset);
/**
* gst_jpeg_parse:
@ -301,13 +290,13 @@ struct _GstJpegScanOffsetSize
* @size: The size of @data
* @offset: The offset from which to start parsing
*
* Parses the JPEG bitstream contained in @data, and returns the detected
* segments as a newly-allocated list of #GstJpegTypeOffsetSize elements.
* The caller is responsible for destroying the list when no longer needed.
* Parses the JPEG bitstream contained in @data, and returns the
* detected segment as a #GstJpegMarkerSegment.
*
* Returns: a #GList of #GstJpegTypeOffsetSize.
* Returns: TRUE if a packet start code was found.
*/
GList *gst_jpeg_parse (const guint8 * data,
gboolean gst_jpeg_parse (GstJpegMarkerSegment * seg,
const guint8 * data,
gsize size,
guint offset);
@ -320,9 +309,9 @@ GList *gst_jpeg_parse (const guint8 * data,
*
* Parses the @hdr JPEG frame header structure members from @data.
*
* Returns: a #GstJpegParserResult
* Returns: TRUE if the frame header was correctly parsed.
*/
GstJpegParserResult gst_jpeg_parse_frame_hdr (GstJpegFrameHdr * hdr,
gboolean gst_jpeg_parse_frame_hdr (GstJpegFrameHdr * hdr,
const guint8 * data,
gsize size,
guint offset);
@ -336,9 +325,9 @@ GstJpegParserResult gst_jpeg_parse_frame_hdr (GstJpegFrameHdr * hdr,
*
* Parses the @hdr JPEG scan header structure members from @data.
*
* Returns: a #GstJpegParserResult
* Returns: TRUE if the scan header was correctly parsed
*/
GstJpegParserResult gst_jpeg_parse_scan_hdr (GstJpegScanHdr * hdr,
gboolean gst_jpeg_parse_scan_hdr (GstJpegScanHdr * hdr,
const guint8 * data,
gsize size,
guint offset);
@ -359,9 +348,9 @@ GstJpegParserResult gst_jpeg_parse_scan_hdr (GstJpegScanHdr * hdr,
* (Tq). While doing so, the @valid flag of the specified quantization
* table will also be set to %TRUE.
*
* Returns: a #GstJpegParserResult
* Returns: TRUE if the quantization table was correctly parsed.
*/
GstJpegParserResult gst_jpeg_parse_quant_table (GstJpegQuantTables *quant_tables,
gboolean gst_jpeg_parse_quant_table (GstJpegQuantTables *quant_tables,
const guint8 * data,
gsize size,
guint offset);
@ -381,9 +370,9 @@ GstJpegParserResult gst_jpeg_parse_quant_table (GstJpegQuantTables *qua
* the @valid flag of the specified Huffman table will also be set to
* %TRUE;
*
* Returns: a #GstJpegParserResult
* Returns: TRUE if the Huffman table was correctly parsed.
*/
GstJpegParserResult gst_jpeg_parse_huffman_table (GstJpegHuffmanTables *huf_tables,
gboolean gst_jpeg_parse_huffman_table (GstJpegHuffmanTables *huf_tables,
const guint8 * data,
gsize size,
guint offset);
@ -395,9 +384,9 @@ GstJpegParserResult gst_jpeg_parse_huffman_table (GstJpegHuffmanTables *h
* @size: The size of @data
* @offset: The offset in bytes from which to start parsing @data
*
* Returns: a #GstJpegParserResult
* Returns: TRUE if the restart interval value was correctly parsed.
*/
GstJpegParserResult gst_jpeg_parse_restart_interval (guint * interval,
gboolean gst_jpeg_parse_restart_interval (guint * interval,
const guint8 * data,
gsize size,
guint offset);
@ -409,8 +398,7 @@ GstJpegParserResult gst_jpeg_parse_restart_interval (guint * interval,
* Fills in @huf_tables with the default AC/DC Huffman tables, as
* specified by the JPEG standard.
*/
void gst_jpeg_get_default_huffman_tables (
GstJpegHuffmanTables *huf_tables);
void gst_jpeg_get_default_huffman_tables (GstJpegHuffmanTables *huf_tables);
/**
* gst_jpeg_get_default_quantization_table: