mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-09-20 02:50:16 +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

631
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 * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License * modify it under the terms of the GNU Lesser General Public License
@ -19,10 +19,9 @@
* Boston, MA 02110-1301 USA * Boston, MA 02110-1301 USA
*/ */
#include "gstjpegparser.h"
#include <string.h> #include <string.h>
#include <gst/base/gstbytereader.h> #include <gst/base/gstbytereader.h>
#include "gstjpegparser.h"
#ifndef GST_DISABLE_GST_DEBUG #ifndef GST_DISABLE_GST_DEBUG
@ -52,19 +51,6 @@ ensure_debug_category (void)
#define DEBUG_PRINT_COMMENT 0 #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 { \ #define READ_UINT8(reader, val) G_STMT_START { \
if (!gst_byte_reader_get_uint8 ((reader), &(val))) { \ if (!gst_byte_reader_get_uint8 ((reader), &(val))) { \
GST_WARNING ("failed to read uint8"); \ GST_WARNING ("failed to read uint8"); \
@ -81,11 +67,11 @@ ensure_debug_category (void)
#define READ_BYTES(reader, buf, length) G_STMT_START { \ #define READ_BYTES(reader, buf, length) G_STMT_START { \
const guint8 *vals; \ const guint8 *vals; \
if (!gst_byte_reader_get_data(reader, length, &vals)) { \ if (!gst_byte_reader_get_data (reader, length, &vals)) { \
GST_WARNING("failed to read bytes, size:%d", length); \ GST_WARNING ("failed to read bytes, size:%d", length); \
goto failed; \ goto failed; \
} \ } \
memcpy(buf, vals, length); \ memcpy (buf, vals, length); \
} G_STMT_END } G_STMT_END
#define U_READ_UINT8(reader, val) G_STMT_START { \ #define U_READ_UINT8(reader, val) G_STMT_START { \
@ -97,83 +83,74 @@ ensure_debug_category (void)
} G_STMT_END } 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 */ /* CCITT T.81, Annex K.1 Quantization tables for luminance and chrominance components */
/* only for 8-bit per sample image */ /* only for 8-bit per sample image */
static const GstJpegQuantTables /* *INDENT-OFF* */
default_quant_tables_zigzag = { static const GstJpegQuantTables default_quant_tables_zigzag = {
.quant_tables = { .quant_tables = {
/* luma */ /* luma */
{0, { 0x10, 0x0b, 0x0c, 0x0e, 0x0c, 0x0a, 0x10, 0x0e, {0, {0x10, 0x0b, 0x0c, 0x0e, 0x0c, 0x0a, 0x10, 0x0e,
0x0d, 0x0e, 0x12, 0x11, 0x10, 0x13, 0x18, 0x27, 0x0d, 0x0e, 0x12, 0x11, 0x10, 0x13, 0x18, 0x27,
0x1a, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23, 0x25, 0x1a, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23, 0x25,
0x1d, 0x28, 0x3a, 0x33, 0x3d, 0x3c, 0x39, 0x33, 0x1d, 0x28, 0x3a, 0x33, 0x3d, 0x3c, 0x39, 0x33,
0x38, 0x37, 0x40, 0x48, 0x5c, 0x4e, 0x40, 0xa8, 0x38, 0x37, 0x40, 0x48, 0x5c, 0x4e, 0x40, 0xa8,
0x57, 0x45, 0x37, 0x38, 0x50, 0x6d, 0xb5, 0x57, 0x57, 0x45, 0x37, 0x38, 0x50, 0x6d, 0xb5, 0x57,
0x5f, 0x62, 0x67, 0x68, 0x67, 0x3e, 0x4d, 0x71, 0x5f, 0x62, 0x67, 0x68, 0x67, 0x3e, 0x4d, 0x71,
0x79, 0x70, 0x64, 0x78, 0x5c, 0x65, 0x67, 0x63 }, TRUE }, 0x79, 0x70, 0x64, 0x78, 0x5c, 0x65, 0x67, 0x63}, TRUE},
/* chroma */ /* chroma */
{0, { 0x11, 0x12, 0x12, 0x18, 0x15, 0x18, 0x2f, 0x1a, {0, {0x11, 0x12, 0x12, 0x18, 0x15, 0x18, 0x2f, 0x1a,
0x1a, 0x2f, 0x63, 0x42, 0x38, 0x42, 0x63, 0x63, 0x1a, 0x2f, 0x63, 0x42, 0x38, 0x42, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63 }, TRUE }, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63}, TRUE},
/* chroma */ /* chroma */
{0, { 0x11, 0x12, 0x12, 0x18, 0x15, 0x18, 0x2f, 0x1a, {0, {0x11, 0x12, 0x12, 0x18, 0x15, 0x18, 0x2f, 0x1a,
0x1a, 0x2f, 0x63, 0x42, 0x38, 0x42, 0x63, 0x63, 0x1a, 0x2f, 0x63, 0x42, 0x38, 0x42, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63 }, TRUE }, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63}, TRUE},
{0, } {0,}
} }
}; };
/* *INDENT-ON* */
/* Table K.3: typical Huffman tables for 8-bit precision luminance and chrominance */ /* Table K.3: typical Huffman tables for 8-bit precision luminance and chrominance */
/* /* *INDENT-OFF* */
0..GST_JPEG_MAX_SCAN_COMPONENTS -1, DC huffman tables static const GstJpegHuffmanTables default_huf_tables = {
GST_JPEG_MAX_SCAN_COMPONENTS...GST_JPEG_MAX_SCAN_COMPONENTS*2-1, AC huffman tables
*/
static const
GstJpegHuffmanTables default_huf_tables = {
.dc_tables = { .dc_tables = {
/* DC luma */ /* DC luma */
{ { 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, {{0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b }, 0x08, 0x09, 0x0a, 0x0b},
TRUE TRUE},
},
/* DC chroma */ /* DC chroma */
{ { 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, {{0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 }, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00},
{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b }, 0x08, 0x09, 0x0a, 0x0b},
TRUE TRUE},
},
/* DC chroma */ /* DC chroma */
{ { 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, {{0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 }, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00},
{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b }, 0x08, 0x09, 0x0a, 0x0b},
TRUE TRUE},
}, {{0x0,},
{ { 0x0 }, {0x0,}
{ 0x0 }
} }
}, },
.ac_tables = { .ac_tables = {
/* AC luma */ /* AC luma */
{ { 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, {{0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03,
0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7d }, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7d},
{ 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, {0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
@ -194,12 +171,11 @@ GstJpegHuffmanTables default_huf_tables = {
0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
0xf9, 0xfa}, 0xf9, 0xfa},
TRUE TRUE},
},
/* AC chroma */ /* AC chroma */
{ { 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, {{0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04,
0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77 }, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77},
{ 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, {0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
@ -219,13 +195,12 @@ GstJpegHuffmanTables default_huf_tables = {
0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
0xf9, 0xfa }, 0xf9, 0xfa},
TRUE TRUE},
},
/* AC chroma */ /* AC chroma */
{ { 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, {{0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04,
0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77 }, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77},
{ 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, {0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
@ -245,316 +220,336 @@ GstJpegHuffmanTables default_huf_tables = {
0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
0xf9, 0xfa }, 0xf9, 0xfa},
TRUE TRUE},
}, {{0x00,},
{ { 0x00 }, {0x00,}
{ 0x00 }
} }
} }
}; };
/* *INDENT-ON* */
static gboolean static inline gboolean
jpeg_parse_to_next_marker (GstByteReader * reader, guint8 * marker) jpeg_parse_to_next_marker (GstByteReader * br, guint8 * marker)
{ {
guint8 value; gint ofs;
while (gst_byte_reader_get_uint8 (reader, &value)) { ofs = gst_jpeg_scan_for_marker_code (br->data, br->size, br->byte);
if (value != 0xFF) if (ofs < 0)
continue; return FALSE;
while (value == 0xFF) {
READ_UINT8 (reader, value); if (marker)
} *marker = br->data[ofs + 1];
if (value == 0x00) gst_byte_reader_skip (br, ofs - br->byte + 2);
continue;
*marker = value;
return TRUE; 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: failed:
return FALSE; return FALSE;
} }
GstJpegParserResult gboolean
gst_jpeg_parse_frame_hdr (GstJpegFrameHdr * frame_hdr, gst_jpeg_parse_quant_table (GstJpegQuantTables * quant_tables,
const guint8 * data, gsize size, guint offset) const guint8 * data, gsize size, guint offset)
{ {
GstByteReader bytes_reader = GST_BYTE_READER_INIT (data + offset, size - offset); GstByteReader br;
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;
GstJpegQuantTable *quant_table; GstJpegQuantTable *quant_table;
guint8 val; guint16 length;
guint8 table_index; guint8 val, table_index;
guint i; guint i;
g_assert (quant_tables && data && size); g_return_val_if_fail (quant_tables != NULL, FALSE);
while (gst_byte_reader_get_remaining (&bytes_reader)) { g_return_val_if_fail (data != NULL, FALSE);
U_READ_UINT8 (&bytes_reader, val); 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); table_index = (val & 0x0f);
CHECK_FAILED (table_index < GST_JPEG_MAX_SCAN_COMPONENTS, g_return_val_if_fail (table_index < GST_JPEG_MAX_SCAN_COMPONENTS, FALSE);
GST_JPEG_PARSER_BROKEN_DATA);
quant_table = &quant_tables->quant_tables[table_index]; quant_table = &quant_tables->quant_tables[table_index];
quant_table->quant_precision = ((val >> 4) & 0x0f); 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), g_return_val_if_fail (gst_byte_reader_get_remaining (&br) >=
GST_JPEG_PARSER_BROKEN_DATA); GST_JPEG_MAX_QUANT_ELEMENTS * (1 + ! !quant_table->quant_precision),
FALSE);
for (i = 0; i < GST_JPEG_MAX_QUANT_ELEMENTS; i++) { for (i = 0; i < GST_JPEG_MAX_QUANT_ELEMENTS; i++) {
if (!quant_table->quant_precision) { /* 8-bit values */ 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; quant_table->quant_table[i] = val;
} else { /* 16-bit values */ } 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; quant_table->valid = TRUE;
} }
return GST_JPEG_PARSER_OK; return TRUE;
wrong_state:
return result;
} }
GstJpegParserResult gboolean
gst_jpeg_parse_restart_interval (guint * interval, gst_jpeg_parse_restart_interval (guint * interval,
const guint8 * data, gsize size, guint offset) const guint8 * data, gsize size, guint offset)
{ {
GstByteReader bytes_reader = GST_BYTE_READER_INIT (data + offset, size - offset); GstByteReader br;
guint16 tmp; guint16 length, val;
g_assert (interval && data && size); g_return_val_if_fail (interval != NULL, FALSE);
READ_UINT16 (&bytes_reader, tmp); g_return_val_if_fail (data != NULL, FALSE);
*interval = tmp; g_return_val_if_fail (size > offset, FALSE);
return GST_JPEG_PARSER_OK;
failed: size -= offset;
return GST_JPEG_PARSER_BROKEN_DATA; 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 void
gst_jpeg_get_default_huffman_tables (GstJpegHuffmanTables *huf_tables) gst_jpeg_get_default_huffman_tables (GstJpegHuffmanTables * huf_tables)
{ {
g_assert (huf_tables); g_assert (huf_tables);
memcpy (huf_tables, &default_huf_tables, sizeof (GstJpegHuffmanTables)); memcpy (huf_tables, &default_huf_tables, sizeof (*huf_tables));
} }
void void
gst_jpeg_get_default_quantization_tables (GstJpegQuantTables *quant_tables) gst_jpeg_get_default_quantization_tables (GstJpegQuantTables * quant_tables)
{ {
g_assert (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 gboolean
jpeg_scan_to_end (const guint8 *start, guint32 size) 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) { g_return_val_if_fail (seg != NULL, FALSE);
if (*pos != 0xFF)
continue; if (size <= offset) {
while (*pos == 0xFF && pos + 1 < end) GST_DEBUG ("failed to parse from offset %u, buffer is too small", offset);
++pos; return FALSE;
if (*pos == 0x00 || *pos == 0xFF ||
(*pos >= GST_JPEG_MARKER_RST_MIN && *pos <= GST_JPEG_MARKER_RST_MAX))
continue;
break;
} }
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; size -= offset;
gst_byte_reader_init (&br, &data[offset], size);
if ((gssize)size <= 0) { if (!jpeg_parse_to_next_marker (&br, &seg->marker)) {
GST_DEBUG ("Can't parse from offset %d, buffer is too small", offset); GST_DEBUG ("failed to find marker code");
return NULL; 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 */ /* Try to find end of segment */
if (!jpeg_parse_to_next_marker (&bytes_reader, &marker) || switch (seg->marker) {
marker != GST_JPEG_MARKER_SOI) case GST_JPEG_MARKER_SOI:
goto failed; case GST_JPEG_MARKER_EOI:
fixed_size_segment:
while (jpeg_parse_to_next_marker (&bytes_reader, &marker)) { seg->size = 2;
if (marker == GST_JPEG_MARKER_EOI)
break; break;
READ_UINT16 (&bytes_reader, header_length); case (GST_JPEG_MARKER_SOF_MIN + 0): /* Lf */
if (header_length < 2 || case (GST_JPEG_MARKER_SOF_MIN + 1): /* Lf */
gst_byte_reader_get_remaining (&bytes_reader) < header_length - 2) case (GST_JPEG_MARKER_SOF_MIN + 2): /* Lf */
goto failed; case (GST_JPEG_MARKER_SOF_MIN + 3): /* Lf */
case (GST_JPEG_MARKER_SOF_MIN + 9): /* Lf */
seg = gst_jpeg_segment_new (marker, case (GST_JPEG_MARKER_SOF_MIN + 10): /* Lf */
gst_byte_reader_get_pos(&bytes_reader) + offset, case (GST_JPEG_MARKER_SOF_MIN + 11): /* Lf */
header_length - 2); case GST_JPEG_MARKER_SOS: /* Ls */
segments = g_list_prepend(segments, seg); case GST_JPEG_MARKER_DQT: /* Lq */
gst_byte_reader_skip (&bytes_reader, header_length - 2); case GST_JPEG_MARKER_DHT: /* Lh */
case GST_JPEG_MARKER_DAC: /* La */
if (seg->type == GST_JPEG_MARKER_SOS) { case GST_JPEG_MARKER_DRI: /* Lr */
GstJpegScanOffsetSize * const scan_seg = (GstJpegScanOffsetSize *)seg; case GST_JPEG_MARKER_COM: /* Lc */
scan_start = gst_byte_reader_peek_data_unchecked (&bytes_reader); case GST_JPEG_MARKER_DNL: /* Ld */
scan_size = jpeg_scan_to_end (scan_start, variable_size_segment:
gst_byte_reader_get_remaining (&bytes_reader)); READ_UINT16 (&br, length);
if (scan_size <= 0) seg->size = length;
break; break;
scan_seg->data_offset = gst_byte_reader_get_pos (&bytes_reader) + offset; default:
scan_seg->data_size = scan_size; /* Application data segment length (Lp) */
gst_byte_reader_skip (&bytes_reader, scan_size); 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 TRUE;
return g_list_reverse (segments);
failed: failed:
{ return FALSE;
GST_WARNING ("Failed to parse");
return g_list_reverse (segments);
}
} }

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

@ -1,7 +1,7 @@
/* /*
* gstjpegparser.h - JPEG parser * 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 * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License * 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 _GstJpegScanHdr GstJpegScanHdr;
typedef struct _GstJpegFrameComponent GstJpegFrameComponent; typedef struct _GstJpegFrameComponent GstJpegFrameComponent;
typedef struct _GstJpegFrameHdr GstJpegFrameHdr; typedef struct _GstJpegFrameHdr GstJpegFrameHdr;
typedef struct _GstJpegTypeOffsetSize GstJpegTypeOffsetSize; typedef struct _GstJpegMarkerSegment GstJpegMarkerSegment;
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;
/** /**
* GstJpegMarkerCode: * GstJpegMarkerCode:
@ -124,7 +106,6 @@ typedef enum {
* @GST_JPEG_PROFILE_EXTENDED: Extended sequential DCT * @GST_JPEG_PROFILE_EXTENDED: Extended sequential DCT
* @GST_JPEG_PROFILE_PROGRESSIVE: Progressive DCT * @GST_JPEG_PROFILE_PROGRESSIVE: Progressive DCT
* @GST_JPEG_PROFILE_LOSSLESS: Lossless (sequential) * @GST_JPEG_PROFILE_LOSSLESS: Lossless (sequential)
* @GST_JPEG_PROFILE_ARITHMETIC: Flag for arithmetic coding
* *
* JPEG encoding processes. * JPEG encoding processes.
*/ */
@ -133,9 +114,20 @@ typedef enum {
GST_JPEG_PROFILE_EXTENDED = 0x01, GST_JPEG_PROFILE_EXTENDED = 0x01,
GST_JPEG_PROFILE_PROGRESSIVE = 0x02, GST_JPEG_PROFILE_PROGRESSIVE = 0x02,
GST_JPEG_PROFILE_LOSSLESS = 0x03, GST_JPEG_PROFILE_LOSSLESS = 0x03,
GST_JPEG_PROFILE_ARITHMETIC = 0x80
} GstJpegProfile; } 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: * GstJpegQuantTable:
* @quant_precision: Quantization table element precision (Pq) * @quant_precision: Quantization table element precision (Pq)
@ -241,7 +233,6 @@ struct _GstJpegFrameComponent
/** /**
* GstJpegFrameHdr: * GstJpegFrameHdr:
* @profile: JPEG encoding process (see #GstJpegProfile)
* @sample_precision: Sample precision (P) * @sample_precision: Sample precision (P)
* @height: Number of lines (Y) * @height: Number of lines (Y)
* @width: Number of samples per line (X) * @width: Number of samples per line (X)
@ -253,7 +244,6 @@ struct _GstJpegFrameComponent
*/ */
struct _GstJpegFrameHdr struct _GstJpegFrameHdr
{ {
guint8 profile;
guint8 sample_precision; /* 2 .. 16 */ guint8 sample_precision; /* 2 .. 16 */
guint16 width; /* 1 .. 65535 */ guint16 width; /* 1 .. 65535 */
guint16 height; /* 0 .. 65535 */ guint16 height; /* 0 .. 65535 */
@ -262,38 +252,37 @@ struct _GstJpegFrameHdr
}; };
/** /**
* GstJpegTypeOffsetSize: * GstJpegMarkerSegment:
* @type: The type of the segment that starts at @offset * @type: The type of the segment that starts at @offset
* @offset: The offset to the segment start in bytes * @offset: The offset to the segment start in bytes. This is the
* @size: The size in bytes of the segment, or -1 if the end was not found * 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. * A structure that contains the type of a segment, its offset and its size.
*/ */
struct _GstJpegTypeOffsetSize struct _GstJpegMarkerSegment
{ {
guint8 type; guint8 marker;
guint offset; guint offset;
gint size; gint size;
}; };
/** /**
* GstJpegScanOffsetSize: * gst_jpeg_scan_for_marker_code:
* @header: The header info associated to the scan * @data: The data to parse
* @data_offset: The offset to the first entropy-coded segment in bytes * @size: The size of @data
* @data_size: The size in bytes of the scan data, including all ECS * @offset: The offset from which to start parsing
* and RST segments, or -1 if the end was not found
* *
* A structure that contains information on a scan. A scan comprises of the * Scans the JPEG bitstream contained in @data for the next marker
* scan @header, and all entropy-coded segment (ECS) and restart marker (RST) * code. If found, the function returns an offset to the marker code,
* associated to it. The header type MUST be set to @GST_JPEG_MARKER_SOS. * 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 gint gst_jpeg_scan_for_marker_code (const guint8 * data,
{ gsize size,
GstJpegTypeOffsetSize header; guint offset);
guint data_offset;
gint data_size;
};
/** /**
* gst_jpeg_parse: * gst_jpeg_parse:
@ -301,13 +290,13 @@ struct _GstJpegScanOffsetSize
* @size: The size of @data * @size: The size of @data
* @offset: The offset from which to start parsing * @offset: The offset from which to start parsing
* *
* Parses the JPEG bitstream contained in @data, and returns the detected * Parses the JPEG bitstream contained in @data, and returns the
* segments as a newly-allocated list of #GstJpegTypeOffsetSize elements. * detected segment as a #GstJpegMarkerSegment.
* The caller is responsible for destroying the list when no longer needed.
* *
* 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, gsize size,
guint offset); guint offset);
@ -320,9 +309,9 @@ GList *gst_jpeg_parse (const guint8 * data,
* *
* Parses the @hdr JPEG frame header structure members from @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, const guint8 * data,
gsize size, gsize size,
guint offset); guint offset);
@ -336,9 +325,9 @@ GstJpegParserResult gst_jpeg_parse_frame_hdr (GstJpegFrameHdr * hdr,
* *
* Parses the @hdr JPEG scan header structure members from @data. * 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, const guint8 * data,
gsize size, gsize size,
guint offset); 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 * (Tq). While doing so, the @valid flag of the specified quantization
* table will also be set to %TRUE. * 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, const guint8 * data,
gsize size, gsize size,
guint offset); 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 * the @valid flag of the specified Huffman table will also be set to
* %TRUE; * %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, const guint8 * data,
gsize size, gsize size,
guint offset); guint offset);
@ -395,9 +384,9 @@ GstJpegParserResult gst_jpeg_parse_huffman_table (GstJpegHuffmanTables *h
* @size: The size of @data * @size: The size of @data
* @offset: The offset in bytes from which to start parsing @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, const guint8 * data,
gsize size, gsize size,
guint offset); 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 * Fills in @huf_tables with the default AC/DC Huffman tables, as
* specified by the JPEG standard. * specified by the JPEG standard.
*/ */
void gst_jpeg_get_default_huffman_tables ( void gst_jpeg_get_default_huffman_tables (GstJpegHuffmanTables *huf_tables);
GstJpegHuffmanTables *huf_tables);
/** /**
* gst_jpeg_get_default_quantization_table: * gst_jpeg_get_default_quantization_table: