[FFmpeg-devel] [PATCH v2 24/36] lavc/cbs: Add JPEG support

Xiang, Haihao haihao.xiang at intel.com
Fri Jun 15 03:52:34 EEST 2018


On Fri, 2018-06-08 at 00:43 +0100, Mark Thompson wrote:
> ---
>  configure                             |   2 +
>  libavcodec/Makefile                   |   1 +
>  libavcodec/cbs.c                      |   6 +
>  libavcodec/cbs_internal.h             |   1 +
>  libavcodec/cbs_jpeg.c                 | 513
> ++++++++++++++++++++++++++++++++++
>  libavcodec/cbs_jpeg.h                 | 128 +++++++++
>  libavcodec/cbs_jpeg_syntax_template.c | 191 +++++++++++++
>  7 files changed, 842 insertions(+)
>  create mode 100644 libavcodec/cbs_jpeg.c
>  create mode 100644 libavcodec/cbs_jpeg.h
>  create mode 100644 libavcodec/cbs_jpeg_syntax_template.c
> 
> diff --git a/configure b/configure
> index 790f55be14..d908283954 100755
> --- a/configure
> +++ b/configure
> @@ -2244,6 +2244,7 @@ CONFIG_EXTRA="
>      cbs
>      cbs_h264
>      cbs_h265
> +    cbs_jpeg
>      cbs_mpeg2
>      cbs_vp9
>      dirac_parse
> @@ -2507,6 +2508,7 @@ threads_if_any="$THREADS_LIST"
>  # subsystems
>  cbs_h264_select="cbs golomb"
>  cbs_h265_select="cbs golomb"
> +cbs_jpeg_select="cbs"
>  cbs_mpeg2_select="cbs"
>  cbs_vp9_select="cbs"
>  dct_select="rdft"
> diff --git a/libavcodec/Makefile b/libavcodec/Makefile
> index 3ab071a039..2a1e0de110 100644
> --- a/libavcodec/Makefile
> +++ b/libavcodec/Makefile
> @@ -64,6 +64,7 @@ OBJS-$(CONFIG_CABAC)                   += cabac.o
>  OBJS-$(CONFIG_CBS)                     += cbs.o
>  OBJS-$(CONFIG_CBS_H264)                += cbs_h2645.o h2645_parse.o
>  OBJS-$(CONFIG_CBS_H265)                += cbs_h2645.o h2645_parse.o
> +OBJS-$(CONFIG_CBS_JPEG)                += cbs_jpeg.o
>  OBJS-$(CONFIG_CBS_MPEG2)               += cbs_mpeg2.o
>  OBJS-$(CONFIG_CBS_VP9)                 += cbs_vp9.o
>  OBJS-$(CONFIG_CRYSTALHD)               += crystalhd.o
> diff --git a/libavcodec/cbs.c b/libavcodec/cbs.c
> index be6c043b58..bb3ce95971 100644
> --- a/libavcodec/cbs.c
> +++ b/libavcodec/cbs.c
> @@ -35,6 +35,9 @@ static const CodedBitstreamType *cbs_type_table[] = {
>  #if CONFIG_CBS_H265
>      &ff_cbs_type_h265,
>  #endif
> +#if CONFIG_CBS_JPEG
> +    &ff_cbs_type_jpeg,
> +#endif
>  #if CONFIG_CBS_MPEG2
>      &ff_cbs_type_mpeg2,
>  #endif
> @@ -50,6 +53,9 @@ const enum AVCodecID ff_cbs_all_codec_ids[] = {
>  #if CONFIG_CBS_H265
>      AV_CODEC_ID_H265,
>  #endif
> +#if CONFIG_CBS_JPEG
> +    AV_CODEC_ID_MJPEG,
> +#endif
>  #if CONFIG_CBS_MPEG2
>      AV_CODEC_ID_MPEG2VIDEO,
>  #endif
> diff --git a/libavcodec/cbs_internal.h b/libavcodec/cbs_internal.h
> index 172b8a2515..e0e912e28e 100644
> --- a/libavcodec/cbs_internal.h
> +++ b/libavcodec/cbs_internal.h
> @@ -88,6 +88,7 @@ int ff_cbs_write_unsigned(CodedBitstreamContext *ctx,
> PutBitContext *pbc,
>  
>  extern const CodedBitstreamType ff_cbs_type_h264;
>  extern const CodedBitstreamType ff_cbs_type_h265;
> +extern const CodedBitstreamType ff_cbs_type_jpeg;
>  extern const CodedBitstreamType ff_cbs_type_mpeg2;
>  extern const CodedBitstreamType ff_cbs_type_vp9;
>  
> diff --git a/libavcodec/cbs_jpeg.c b/libavcodec/cbs_jpeg.c
> new file mode 100644
> index 0000000000..365db73394
> --- /dev/null
> +++ b/libavcodec/cbs_jpeg.c
> @@ -0,0 +1,513 @@
> +/*
> + * This file is part of FFmpeg.
> + *
> + * FFmpeg is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; either
> + * version 2.1 of the License, or (at your option) any later version.
> + *
> + * FFmpeg is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with FFmpeg; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
> USA
> + */
> +
> +#include "cbs.h"
> +#include "cbs_internal.h"
> +#include "cbs_jpeg.h"
> +
> +
> +#define HEADER(name) do { \
> +        ff_cbs_trace_header(ctx, name); \
> +    } while (0)
> +
> +#define CHECK(call) do { \
> +        err = (call); \
> +        if (err < 0) \
> +            return err; \
> +    } while (0)
> +
> +#define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__
> }) : NULL)
> +
> +#define u(width, name, range_min, range_max) \
> +    xu(width, name, range_min, range_max, 0)
> +#define us(width, name, sub, range_min, range_max) \
> +    xu(width, name, range_min, range_max, 1, sub)
> +
> +
> +#define READ
> +#define READWRITE read
> +#define RWContext GetBitContext
> +#define FUNC(name) cbs_jpeg_read_ ## name
> +
> +#define xu(width, name, range_min, range_max, subs, ...) do { \
> +        uint32_t value = range_min; \
> +        CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
> +                                   SUBSCRIPTS(subs, __VA_ARGS__), \
> +                                   &value, range_min, range_max)); \
> +        current->name = value; \
> +    } while (0)
> +
> +#include "cbs_jpeg_syntax_template.c"
> +
> +#undef READ
> +#undef READWRITE
> +#undef RWContext
> +#undef FUNC
> +#undef xu
> +
> +#define WRITE
> +#define READWRITE write
> +#define RWContext PutBitContext
> +#define FUNC(name) cbs_jpeg_write_ ## name
> +
> +#define xu(width, name, range_min, range_max, subs, ...) do { \
> +        uint32_t value = current->name; \
> +        CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
> +                                    SUBSCRIPTS(subs, __VA_ARGS__), \
> +                                    value, range_min, range_max)); \
> +    } while (0)
> +
> +
> +#include "cbs_jpeg_syntax_template.c"
> +
> +#undef READ
> +#undef READWRITE
> +#undef RWContext
> +#undef FUNC
> +#undef xu
> +
> +
> +static void cbs_jpeg_free_application_data(void *unit, uint8_t *content)
> +{
> +    JPEGRawApplicationData *ad = (JPEGRawApplicationData*)content;
> +    av_buffer_unref(&ad->Ap_ref);
> +    av_freep(&content);
> +}
> +
> +static void cbs_jpeg_free_scan(void *unit, uint8_t *content)
> +{
> +    JPEGRawScan *scan = (JPEGRawScan*)content;
> +    av_buffer_unref(&scan->data_ref);
> +    av_freep(&content);
> +}
> +
> +static int cbs_jpeg_split_fragment(CodedBitstreamContext *ctx,
> +                                   CodedBitstreamFragment *frag,
> +                                   int header)
> +{
> +    AVBufferRef *data_ref;
> +    uint8_t *data;
> +    size_t data_size;
> +    int unit, start, end, marker, next_start, next_marker;
> +    int err, i, j, length;
> +
> +    if (frag->data_size < 4) {
> +        // Definitely too short to be meaningful.
> +        return AVERROR_INVALIDDATA;
> +    }
> +
> +    for (i = 0; i + 1 < frag->data_size && frag->data[i] != 0xff; i++);
> +    if (i > 0) {
> +        av_log(ctx->log_ctx, AV_LOG_WARNING, "Discarding %d bytes at "
> +               "beginning of image.\n", i);
> +    }
> +    for (++i; i + 1 < frag->data_size && frag->data[i] == 0xff; i++);
> +    if (i + 1 >= frag->data_size && frag->data[i]) {
> +        av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
> +               "no SOI marker found.\n");
> +        return AVERROR_INVALIDDATA;
> +    }
> +    marker = frag->data[i];
> +    if (marker != JPEG_MARKER_SOI) {
> +        av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: first "
> +               "marker is %02x, should be SOI.\n", marker);
> +        return AVERROR_INVALIDDATA;
> +    }
> +    for (++i; i + 1 < frag->data_size && frag->data[i] == 0xff; i++);
> +    if (i + 1 >= frag->data_size) {
> +        av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
> +               "no image content found.\n");
> +        return AVERROR_INVALIDDATA;
> +    }
> +    marker = frag->data[i];
> +    start  = i + 1;
> +
> +    for (unit = 0;; unit++) {
> +        if (marker == JPEG_MARKER_EOI) {
> +            break;
> +        } else if (marker == JPEG_MARKER_SOS) {
> +            for (i = start; i + 1 < frag->data_size; i++) {
> +                if (frag->data[i] != 0xff)
> +                    continue;
> +                end = i;
> +                for (++i; i + 1 < frag->data_size &&
> +                          frag->data[i] == 0xff; i++);
> +                if (i + 1 >= frag->data_size) {
> +                    next_marker = -1;
> +                } else {
> +                    if (frag->data[i] == 0x00)
> +                        continue;
> +                    next_marker = frag->data[i];
> +                    next_start  = i + 1;
> +                }
> +                break;
> +            }
> +        } else {
> +            i = start;
> +            if (i + 2 > frag->data_size) {
> +                av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
> +                       "truncated at %02x marker.\n", marker);
> +                return AVERROR_INVALIDDATA;
> +            }
> +            length = AV_RB16(frag->data + i);
> +            if (i + length > frag->data_size) {
> +                av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
> +                       "truncated at %02x marker segment.\n", marker);
> +                return AVERROR_INVALIDDATA;
> +            }
> +            end = start + length;
> +
> +            i = end;
> +            if (frag->data[i] != 0xff) {
> +                next_marker = -1;
> +            } else {
> +                for (++i; i + 1 < frag->data_size &&
> +                          frag->data[i] == 0xff; i++);
> +                if (i + 1 >= frag->data_size) {
> +                    next_marker = -1;
> +                } else {
> +                    next_marker = frag->data[i];
> +                    next_start  = i + 1;
> +                }
> +            }
> +        }
> +
> +        if (marker == JPEG_MARKER_SOS) {
> +            length = AV_RB16(frag->data + start);
> +
> +            data_ref = NULL;
> +            data     = av_malloc(end - start +
> +                                 AV_INPUT_BUFFER_PADDING_SIZE);
> +            if (!data)
> +                return AVERROR(ENOMEM);
> +
> +            memcpy(data, frag->data + start, length);
> +            for (i = start + length, j = length; i < end; i++, j++) {
> +                if (frag->data[i] == 0xff) {
> +                    while (frag->data[i] == 0xff)
> +                        ++i;
> +                    data[j] = 0xff;
> +                } else {
> +                    data[j] = frag->data[i];
> +                }
> +            }
> +            data_size = j;
> +
> +            memset(data + data_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
> +
> +        } else {
> +            data      = frag->data + start;
> +            data_size = end - start;
> +            data_ref  = frag->data_ref;
> +        }
> +
> +        err = ff_cbs_insert_unit_data(ctx, frag, unit, marker,
> +                                      data, data_size, data_ref);
> +        if (err < 0) {
> +            if (!data_ref)
> +                av_freep(&data);
> +            return err;
> +        }
> +
> +        if (next_marker == -1)
> +            break;
> +        marker = next_marker;
> +        start  = next_start;
> +    }
> +
> +    return 0;
> +}
> +
> +static int cbs_jpeg_read_unit(CodedBitstreamContext *ctx,
> +                              CodedBitstreamUnit *unit)
> +{
> +    GetBitContext gbc;
> +    int err;
> +
> +    err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
> +    if (err < 0)
> +        return err;
> +
> +    if (unit->type >= JPEG_MARKER_SOF0 &&
> +        unit->type <= JPEG_MARKER_SOF3) {
> +        err = ff_cbs_alloc_unit_content(ctx, unit,
> +                                        sizeof(JPEGRawFrameHeader),
> +                                        NULL);
> +        if (err < 0)
> +            return err;
> +
> +        err = cbs_jpeg_read_frame_header(ctx, &gbc, unit->content);
> +        if (err < 0)
> +            return err;
> +
> +    } else if (unit->type >= JPEG_MARKER_APPN &&
> +               unit->type <= JPEG_MARKER_APPN + 15) {
> +        err = ff_cbs_alloc_unit_content(ctx, unit,
> +                                        sizeof(JPEGRawApplicationData),
> +                                        &cbs_jpeg_free_application_data);
> +        if (err < 0)
> +            return err;
> +
> +        err = cbs_jpeg_read_application_data(ctx, &gbc, unit->content);
> +        if (err < 0)
> +            return err;
> +
> +    } else if (unit->type == JPEG_MARKER_SOS) {
> +        JPEGRawScan *scan;
> +        int pos;
> +
> +        err = ff_cbs_alloc_unit_content(ctx, unit,
> +                                        sizeof(JPEGRawScan),
> +                                        &cbs_jpeg_free_scan);
> +        if (err < 0)
> +            return err;
> +        scan = unit->content;
> +
> +        err = cbs_jpeg_read_scan_header(ctx, &gbc, &scan->header);
> +        if (err < 0)
> +            return err;
> +
> +        pos = get_bits_count(&gbc);
> +        av_assert0(pos % 8 == 0);
> +        if (pos > 0) {
> +            scan->data_size = unit->data_size - pos / 8;
> +            scan->data_ref  = av_buffer_ref(unit->data_ref);
> +            if (!scan->data_ref)
> +                return AVERROR(ENOMEM);
> +            scan->data = unit->data + pos / 8;
> +        }
> +
> +    } else {
> +        switch (unit->type) {
> +#define SEGMENT(marker, type, func) \
> +        case JPEG_MARKER_ ## marker: \
> +            { \
> +                err = ff_cbs_alloc_unit_content(ctx, unit, \
> +                                                sizeof(type), NULL); \
> +                if (err < 0) \
> +                    return err; \
> +                err = cbs_jpeg_read_ ## func(ctx, &gbc, unit->content); \
> +                if (err < 0) \
> +                    return err; \
> +            } \
> +            break
> +            SEGMENT(DQT, JPEGRawQuantisationTableSpecification, dqt);
> +            SEGMENT(DHT, JPEGRawHuffmanTableSpecification,      dht);
> +            SEGMENT(COM, JPEGRawComment,                    comment);

A free function should be provided for JPEGRawComment as JPEGRawComment includes
a AVBufferRef pointer. 


> +#undef SEGMENT
> +        default:
> +            return AVERROR(ENOSYS);
> +        }
> +    }
> +
> +    return 0;
> +}
> +
> +static int cbs_jpeg_write_scan(CodedBitstreamContext *ctx,
> +                               CodedBitstreamUnit *unit,
> +                               PutBitContext *pbc)
> +{
> +    JPEGRawScan *scan = unit->content;
> +    int i, err;
> +
> +    err = cbs_jpeg_write_scan_header(ctx, pbc, &scan->header);
> +    if (err < 0)
> +        return err;
> +
> +    if (scan->data) {
> +        if (scan->data_size * 8 > put_bits_left(pbc))
> +            return AVERROR(ENOSPC);
> +
> +        for (i = 0; i < scan->data_size; i++)
> +            put_bits(pbc, 8, scan->data[i]);
> +    }
> +
> +    return 0;
> +}
> +
> +static int cbs_jpeg_write_segment(CodedBitstreamContext *ctx,
> +                                  CodedBitstreamUnit *unit,
> +                                  PutBitContext *pbc)
> +{
> +    int err;
> +
> +    if (unit->type >= JPEG_MARKER_SOF0 &&
> +        unit->type <= JPEG_MARKER_SOF3) {
> +        err = cbs_jpeg_write_frame_header(ctx, pbc, unit->content);
> +    } else if (unit->type >= JPEG_MARKER_APPN &&
> +               unit->type <= JPEG_MARKER_APPN + 15) {
> +        err = cbs_jpeg_write_application_data(ctx, pbc, unit->content);
> +    } else {
> +        switch (unit->type) {
> +#define SEGMENT(marker, func) \
> +            case JPEG_MARKER_ ## marker: \
> +                err = cbs_jpeg_write_ ## func(ctx, pbc, unit->content); \
> +                break;
> +            SEGMENT(DQT, dqt);
> +            SEGMENT(DHT, dht);
> +            SEGMENT(COM, comment);
> +        default:
> +            return AVERROR_PATCHWELCOME;
> +        }
> +    }
> +
> +    return err;
> +}
> +
> +static int cbs_jpeg_write_unit(CodedBitstreamContext *ctx,
> +                                CodedBitstreamUnit *unit)
> +{
> +    CodedBitstreamJPEGContext *priv = ctx->priv_data;
> +    PutBitContext pbc;
> +    int err;
> +
> +    if (!priv->write_buffer) {
> +        // Initial write buffer size is 1MB.
> +        priv->write_buffer_size = 1024 * 1024;
> +
> +    reallocate_and_try_again:
> +        err = av_reallocp(&priv->write_buffer, priv->write_buffer_size);
> +        if (err < 0) {
> +            av_log(ctx->log_ctx, AV_LOG_ERROR, "Unable to allocate a "
> +                   "sufficiently large write buffer (last attempt "
> +                   "%"SIZE_SPECIFIER" bytes).\n", priv->write_buffer_size);
> +            return err;
> +        }
> +    }
> +
> +    init_put_bits(&pbc, priv->write_buffer, priv->write_buffer_size);
> +
> +    if (unit->type == JPEG_MARKER_SOS)
> +        err = cbs_jpeg_write_scan(ctx, unit, &pbc);
> +    else
> +        err = cbs_jpeg_write_segment(ctx, unit, &pbc);
> +
> +    if (err == AVERROR(ENOSPC)) {
> +        // Overflow.
> +        priv->write_buffer_size *= 2;
> +        goto reallocate_and_try_again;
> +    }
> +    if (err < 0) {
> +        // Write failed for some other reason.
> +        return err;
> +    }
> +
> +    if (put_bits_count(&pbc) % 8)
> +        unit->data_bit_padding = 8 - put_bits_count(&pbc) % 8;
> +    else
> +        unit->data_bit_padding = 0;
> +
> +    unit->data_size = (put_bits_count(&pbc) + 7) / 8;
> +    flush_put_bits(&pbc);
> +
> +    err = ff_cbs_alloc_unit_data(ctx, unit, unit->data_size);
> +    if (err < 0)
> +        return err;
> +
> +    memcpy(unit->data, priv->write_buffer, unit->data_size);
> +
> +    return 0;
> +}
> +
> +static int cbs_jpeg_assemble_fragment(CodedBitstreamContext *ctx,
> +                                       CodedBitstreamFragment *frag)
> +{
> +    const CodedBitstreamUnit *unit;
> +    uint8_t *data;
> +    size_t size, dp, sp;
> +    int i;
> +
> +    size = 4; // SOI + EOI.
> +    for (i = 0; i < frag->nb_units; i++) {
> +        unit = &frag->units[i];
> +        size += 2 + unit->data_size;
> +        if (unit->type == JPEG_MARKER_SOS) {
> +            for (sp = 0; sp < unit->data_size; sp++) {
> +                if (unit->data[sp] == 0xff)
> +                    ++size;
> +            }
> +        }
> +    }
> +
> +    frag->data_ref = av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
> +    if (!frag->data_ref)
> +        return AVERROR(ENOMEM);
> +    data = frag->data_ref->data;
> +
> +    dp = 0;
> +
> +    data[dp++] = 0xff;
> +    data[dp++] = JPEG_MARKER_SOI;
> +
> +    for (i = 0; i < frag->nb_units; i++) {
> +        unit = &frag->units[i];
> +
> +        data[dp++] = 0xff;
> +        data[dp++] = unit->type;
> +
> +        if (unit->type != JPEG_MARKER_SOS) {
> +            memcpy(data + dp, unit->data, unit->data_size);
> +            dp += unit->data_size;
> +        } else {
> +            sp = AV_RB16(unit->data);
> +            av_assert0(sp <= unit->data_size);
> +            memcpy(data + dp, unit->data, sp);
> +            dp += sp;
> +
> +            for (; sp < unit->data_size; sp++) {
> +                if (unit->data[sp] == 0xff) {
> +                    data[dp++] = 0xff;
> +                    data[dp++] = 0x00;
> +                } else {
> +                    data[dp++] = unit->data[sp];
> +                }
> +            }
> +        }
> +    }
> +
> +    data[dp++] = 0xff;
> +    data[dp++] = JPEG_MARKER_EOI;
> +
> +    av_assert0(dp == size);
> +
> +    memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
> +    frag->data      = data;
> +    frag->data_size = size;
> +
> +    return 0;
> +}
> +
> +static void cbs_jpeg_close(CodedBitstreamContext *ctx)
> +{
> +    CodedBitstreamJPEGContext *priv = ctx->priv_data;
> +
> +    av_freep(&priv->write_buffer);
> +}
> +
> +const CodedBitstreamType ff_cbs_type_jpeg = {
> +    .codec_id          = AV_CODEC_ID_MJPEG,
> +
> +    .priv_data_size    = sizeof(CodedBitstreamJPEGContext),
> +
> +    .split_fragment    = &cbs_jpeg_split_fragment,
> +    .read_unit         = &cbs_jpeg_read_unit,
> +    .write_unit        = &cbs_jpeg_write_unit,
> +    .assemble_fragment = &cbs_jpeg_assemble_fragment,
> +
> +    .close             = &cbs_jpeg_close,
> +};
> diff --git a/libavcodec/cbs_jpeg.h b/libavcodec/cbs_jpeg.h
> new file mode 100644
> index 0000000000..f427c4c616
> --- /dev/null
> +++ b/libavcodec/cbs_jpeg.h
> @@ -0,0 +1,128 @@
> +/*
> + * This file is part of FFmpeg.
> + *
> + * FFmpeg is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; either
> + * version 2.1 of the License, or (at your option) any later version.
> + *
> + * FFmpeg is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with FFmpeg; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
> USA
> + */
> +
> +#ifndef AVCODEC_CBS_JPEG_H
> +#define AVCODEC_CBS_JPEG_H
> +
> +#include <stddef.h>
> +#include <stdint.h>
> +
> +
> +enum {
> +    JPEG_MARKER_SOF0    = 0xc0,
> +    JPEG_MARKER_SOF1    = 0xc1,
> +    JPEG_MARKER_SOF2    = 0xc2,
> +    JPEG_MARKER_SOF3    = 0xc3,
> +
> +    JPEG_MARKER_DHT     = 0xc4,
> +    JPEG_MARKER_SOI     = 0xd8,
> +    JPEG_MARKER_EOI     = 0xd9,
> +    JPEG_MARKER_SOS     = 0xda,
> +    JPEG_MARKER_DQT     = 0xdb,
> +
> +    JPEG_MARKER_APPN    = 0xe0,
> +    JPEG_MARKER_JPGN    = 0xf0,
> +    JPEG_MARKER_COM     = 0xfe,
> +};
> +
> +enum {
> +    JPEG_MAX_COMPONENTS = 255,
> +
> +    JPEG_MAX_HEIGHT = 65535,
> +    JPEG_MAX_WIDTH  = 65535,
> +};
> +
> +
> +typedef struct JPEGRawFrameHeader {
> +    uint16_t Lf;
> +    uint8_t  P;
> +    uint16_t Y;
> +    uint16_t X;
> +    uint16_t Nf;
> +
> +    uint8_t  C [JPEG_MAX_COMPONENTS];
> +    uint8_t  H [JPEG_MAX_COMPONENTS];
> +    uint8_t  V [JPEG_MAX_COMPONENTS];
> +    uint8_t  Tq[JPEG_MAX_COMPONENTS];
> +} JPEGRawFrameHeader;
> +
> +typedef struct JPEGRawScanHeader {
> +    uint16_t Ls;
> +    uint8_t  Ns;
> +
> +    uint8_t  Cs[JPEG_MAX_COMPONENTS];
> +    uint8_t  Td[JPEG_MAX_COMPONENTS];
> +    uint8_t  Ta[JPEG_MAX_COMPONENTS];
> +
> +    uint8_t  Ss;
> +    uint8_t  Se;
> +    uint8_t  Ah;
> +    uint8_t  Al;
> +} JPEGRawScanHeader;
> +
> +typedef struct JPEGRawScan {
> +    JPEGRawScanHeader header;
> +    uint8_t          *data;
> +    size_t            data_size;
> +    AVBufferRef      *data_ref;
> +} JPEGRawScan;
> +
> +typedef struct JPEGRawQuantisationTable {
> +    uint8_t  Pq;
> +    uint8_t  Tq;
> +    uint16_t Q[64];
> +} JPEGRawQuantisationTable;
> +
> +typedef struct JPEGRawQuantisationTableSpecification {
> +    uint16_t Lq;
> +    JPEGRawQuantisationTable table[4];
> +} JPEGRawQuantisationTableSpecification;
> +
> +typedef struct JPEGRawHuffmanTable {
> +    uint8_t  Tc;
> +    uint8_t  Th;
> +    uint8_t  L[16];
> +    uint8_t  V[224];
> +} JPEGRawHuffmanTable;
> +
> +typedef struct JPEGRawHuffmanTableSpecification {
> +    uint16_t Lh;
> +    JPEGRawHuffmanTable table[8];
> +} JPEGRawHuffmanTableSpecification;
> +
> +typedef struct JPEGRawApplicationData {
> +    uint16_t     Lp;
> +    uint8_t     *Ap;
> +    AVBufferRef *Ap_ref;
> +} JPEGRawApplicationData;
> +
> +typedef struct JPEGRawComment {
> +    uint16_t     Lc;
> +    uint8_t     *Cm;
> +    AVBufferRef *Cm_ref;
> +} JPEGRawComment;
> +
> +
> +typedef struct CodedBitstreamJPEGContext {
> +    // Write buffer.
> +    uint8_t *write_buffer;
> +    size_t write_buffer_size;
> +} CodedBitstreamJPEGContext;
> +
> +
> +#endif /* AVCODEC_CBS_JPEG_H */
> diff --git a/libavcodec/cbs_jpeg_syntax_template.c
> b/libavcodec/cbs_jpeg_syntax_template.c
> new file mode 100644
> index 0000000000..d3cd9ff62e
> --- /dev/null
> +++ b/libavcodec/cbs_jpeg_syntax_template.c
> @@ -0,0 +1,191 @@
> +/*
> + * This file is part of FFmpeg.
> + *
> + * FFmpeg is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; either
> + * version 2.1 of the License, or (at your option) any later version.
> + *
> + * FFmpeg is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with FFmpeg; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
> USA
> + */
> +
> +static int FUNC(frame_header)(CodedBitstreamContext *ctx, RWContext *rw,
> +                              JPEGRawFrameHeader *current)
> +{
> +    int err, i;
> +
> +    HEADER("Frame Header");
> +
> +    u(16, Lf, 8, 8 + 3 * JPEG_MAX_COMPONENTS);
> +
> +    u(8,  P,  2, 16);
> +    u(16, Y,  0, JPEG_MAX_HEIGHT);
> +    u(16, X,  1, JPEG_MAX_WIDTH);
> +    u(8,  Nf, 1, JPEG_MAX_COMPONENTS);
> +
> +    for (i = 0; i < current->Nf; i++) {
> +        us(8, C[i],  i, 0, JPEG_MAX_COMPONENTS);
> +        us(4, H[i],  i, 1, 4);
> +        us(4, V[i],  i, 1, 4);
> +        us(8, Tq[i], i, 0, 3);
> +    }
> +
> +    return 0;
> +}
> +
> +static int FUNC(quantisation_table)(CodedBitstreamContext *ctx, RWContext
> *rw,
> +                                     JPEGRawQuantisationTable *current)
> +{
> +    int err, i;
> +
> +    u(4, Pq, 0, 1);
> +    u(4, Tq, 0, 3);
> +
> +    if (current->Pq) {
> +        for (i = 0; i < 64; i++)
> +            us(16, Q[i], i, 1, 255);
> +    } else {
> +        for (i = 0; i < 64; i++)
> +            us(8,  Q[i], i, 1, 255);
> +    }
> +
> +    return 0;
> +}
> +
> +static int FUNC(dqt)(CodedBitstreamContext *ctx, RWContext *rw,
> +                     JPEGRawQuantisationTableSpecification *current)
> +{
> +    int err, i, n;
> +
> +    HEADER("Quantisation Tables");
> +
> +    u(16, Lq, 2, 2 + 4 * 65);
> +    n = current->Lq / 65;
> +
> +    for (i = 0; i < n; i++)
> +        CHECK(FUNC(quantisation_table)(ctx, rw, &current->table[i]));
> +
> +    return 0;
> +}
> +
> +static int FUNC(huffman_table)(CodedBitstreamContext *ctx, RWContext *rw,
> +                               JPEGRawHuffmanTable *current)
> +{
> +    int err, i, j, ij;
> +
> +    u(4, Tc, 0, 1);
> +    u(4, Th, 0, 3);
> +
> +    for (i = 0; i < 16; i++)
> +        us(8, L[i], i, 0, 224);
> +
> +    ij = 0;
> +    for (i = 0; i < 16; i++) {
> +        for (j = 0; j < current->L[i]; j++) {
> +            us(8, V[ij], ij, 0, 255);
> +            ++ij;
> +        }
> +    }
> +
> +    return 0;
> +}
> +
> +static int FUNC(dht)(CodedBitstreamContext *ctx, RWContext *rw,
> +                     JPEGRawHuffmanTableSpecification *current)
> +{
> +    int err, i, j, n;
> +
> +    HEADER("Huffman Tables");
> +
> +    u(16, Lh, 2, 2 + 8 * (1 + 16 + 256));
> +
> +    n = 2;
> +    for (i = 0; n < current->Lh; i++) {
> +        CHECK(FUNC(huffman_table)(ctx, rw, &current->table[i]));
> +
> +        ++n;
> +        for (j = 0; j < 16; j++)
> +            n += 1 + current->table[i].L[j];
> +    }
> +
> +    return 0;
> +}
> +
> +static int FUNC(scan_header)(CodedBitstreamContext *ctx, RWContext *rw,
> +                             JPEGRawScanHeader *current)
> +{
> +    int err, j;
> +
> +    HEADER("Scan");
> +
> +    u(16, Ls, 6, 6 + 2 * JPEG_MAX_COMPONENTS);
> +
> +    u(8, Ns, 1, 4);
> +    for (j = 0; j < current->Ns; j++) {
> +        us(8, Cs[j], j, 0, JPEG_MAX_COMPONENTS);
> +        us(4, Td[j], j, 0, 3);
> +        us(4, Ta[j], j, 0, 3);
> +    }
> +
> +    u(8, Ss, 0, 63);
> +    u(8, Se, 0, 63);
> +    u(4, Ah, 0, 13);
> +    u(4, Al, 0, 15);
> +
> +    return 0;
> +}
> +
> +static int FUNC(application_data)(CodedBitstreamContext *ctx, RWContext *rw,
> +                                  JPEGRawApplicationData *current)
> +{
> +    int err, i;
> +
> +    HEADER("Application Data");
> +
> +    u(16, Lp, 2, 65535);
> +
> +    if (current->Lp > 2) {
> +#ifdef READ
> +        current->Ap_ref = av_buffer_alloc(current->Lp - 2);
> +        if (!current->Ap_ref)
> +            return AVERROR(ENOMEM);
> +        current->Ap = current->Ap_ref->data;
> +#endif
> +
> +        for (i = 0; i < current->Lp - 2; i++)
> +            us(8, Ap[i], i, 0, 255);
> +    }
> +
> +    return 0;
> +}
> +
> +static int FUNC(comment)(CodedBitstreamContext *ctx, RWContext *rw,
> +                         JPEGRawComment *current)
> +{
> +    int err, i;
> +
> +    HEADER("Comment");
> +
> +    u(16, Lc, 2, 65535);
> +
> +    if (current->Lc > 2) {
> +#ifdef READ
> +        current->Cm_ref = av_buffer_alloc(current->Lc - 2);
> +        if (!current->Cm_ref)
> +            return AVERROR(ENOMEM);
> +        current->Cm = current->Cm_ref->data;
> +#endif
> +
> +        for (i = 0; i < current->Lc - 2; i++)
> +            us(8, Cm[i], i, 0, 255);
> +    }
> +
> +    return 0;
> +}


More information about the ffmpeg-devel mailing list