FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/cbs_jpeg.c	Lines:	0	209	0.0 %
Date:	2020-07-13 04:22:34	Branches:	0	158	0.0 %


/*
 * 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; \
        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 WRITE
#undef READWRITE
#undef RWContext
#undef FUNC
#undef xu


static void cbs_jpeg_free_application_data(void *opaque, uint8_t *content)
{
    JPEGRawApplicationData *ad = (JPEGRawApplicationData*)content;
    av_buffer_unref(&ad->Ap_ref);
    av_freep(&content);
}

static void cbs_jpeg_free_comment(void *opaque, uint8_t *content)
{
    JPEGRawComment *comment = (JPEGRawComment*)content;
    av_buffer_unref(&comment->Cm_ref);
    av_freep(&content);
}

static void cbs_jpeg_free_scan(void *opaque, 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) {
            next_marker = -1;
            end = start;
            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) {
                    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);

            if (length > end - start)
                return AVERROR_INVALIDDATA;

            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(frag, unit, marker,
                                      data, data_size, data_ref);
        if (err < 0)
            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(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(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(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, free) \
        case JPEG_MARKER_ ## marker: \
            { \
                err = ff_cbs_alloc_unit_content(unit, \
                                                sizeof(type), free); \
                if (err < 0) \
                    return err; \
                err = cbs_jpeg_read_ ## func(ctx, &gbc, unit->content); \
                if (err < 0) \
                    return err; \
            } \
            break
            SEGMENT(DQT, JPEGRawQuantisationTableSpecification, dqt, NULL);
            SEGMENT(DHT, JPEGRawHuffmanTableSpecification,      dht, NULL);
            SEGMENT(COM, JPEGRawComment,  comment, &cbs_jpeg_free_comment);
#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 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);

        av_assert0(put_bits_count(pbc) % 8 == 0);

        flush_put_bits(pbc);

        memcpy(put_bits_ptr(pbc), scan->data, scan->data_size);
        skip_put_bytes(pbc, scan->data_size);
    }

    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,
                               PutBitContext *pbc)
{
    if (unit->type == JPEG_MARKER_SOS)
        return cbs_jpeg_write_scan   (ctx, unit, pbc);
    else
        return cbs_jpeg_write_segment(ctx, unit, pbc);
}

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

const CodedBitstreamType ff_cbs_type_jpeg = {
    .codec_id          = AV_CODEC_ID_MJPEG,

    .split_fragment    = &cbs_jpeg_split_fragment,
    .read_unit         = &cbs_jpeg_read_unit,
    .write_unit        = &cbs_jpeg_write_unit,
    .assemble_fragment = &cbs_jpeg_assemble_fragment,
};


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* This file is part of FFmpeg.
3			*
4			* FFmpeg is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU Lesser General Public
6			* License as published by the Free Software Foundation; either
7			* version 2.1 of the License, or (at your option) any later version.
8			*
9			* FFmpeg is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12			* Lesser General Public License for more details.
13			*
14			* You should have received a copy of the GNU Lesser General Public
15			* License along with FFmpeg; if not, write to the Free Software
16			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17			*/
18
19			#include "cbs.h"
20			#include "cbs_internal.h"
21			#include "cbs_jpeg.h"
22
23
24			#define HEADER(name) do { \
25			ff_cbs_trace_header(ctx, name); \
26			} while (0)
27
28			#define CHECK(call) do { \
29			err = (call); \
30			if (err < 0) \
31			return err; \
32			} while (0)
33
34			#define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
35
36			#define u(width, name, range_min, range_max) \
37			xu(width, name, range_min, range_max, 0, )
38			#define us(width, name, sub, range_min, range_max) \
39			xu(width, name, range_min, range_max, 1, sub)
40
41
42			#define READ
43			#define READWRITE read
44			#define RWContext GetBitContext
45			#define FUNC(name) cbs_jpeg_read_ ## name
46
47			#define xu(width, name, range_min, range_max, subs, ...) do { \
48			uint32_t value; \
49			CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
50			SUBSCRIPTS(subs, __VA_ARGS__), \
51			&value, range_min, range_max)); \
52			current->name = value; \
53			} while (0)
54
55			#include "cbs_jpeg_syntax_template.c"
56
57			#undef READ
58			#undef READWRITE
59			#undef RWContext
60			#undef FUNC
61			#undef xu
62
63			#define WRITE
64			#define READWRITE write
65			#define RWContext PutBitContext
66			#define FUNC(name) cbs_jpeg_write_ ## name
67
68			#define xu(width, name, range_min, range_max, subs, ...) do { \
69			uint32_t value = current->name; \
70			CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
71			SUBSCRIPTS(subs, __VA_ARGS__), \
72			value, range_min, range_max)); \
73			} while (0)
74
75
76			#include "cbs_jpeg_syntax_template.c"
77
78			#undef WRITE
79			#undef READWRITE
80			#undef RWContext
81			#undef FUNC
82			#undef xu
83
84
85			static void cbs_jpeg_free_application_data(void opaque, uint8_t content)
86			{
87			JPEGRawApplicationData ad = (JPEGRawApplicationData)content;
88			av_buffer_unref(&ad->Ap_ref);
89			av_freep(&content);
90			}
91
92			static void cbs_jpeg_free_comment(void opaque, uint8_t content)
93			{
94			JPEGRawComment comment = (JPEGRawComment)content;
95			av_buffer_unref(&comment->Cm_ref);
96			av_freep(&content);
97			}
98
99			static void cbs_jpeg_free_scan(void opaque, uint8_t content)
100			{
101			JPEGRawScan scan = (JPEGRawScan)content;
102			av_buffer_unref(&scan->data_ref);
103			av_freep(&content);
104			}
105
106			static int cbs_jpeg_split_fragment(CodedBitstreamContext *ctx,
107			CodedBitstreamFragment *frag,
108			int header)
109			{
110			AVBufferRef *data_ref;
111			uint8_t *data;
112			size_t data_size;
113			int unit, start, end, marker, next_start, next_marker;
114			int err, i, j, length;
115
116			if (frag->data_size < 4) {
117			// Definitely too short to be meaningful.
118			return AVERROR_INVALIDDATA;
119			}
120
121			for (i = 0; i + 1 < frag->data_size && frag->data[i] != 0xff; i++);
122			if (i > 0) {
123			av_log(ctx->log_ctx, AV_LOG_WARNING, "Discarding %d bytes at "
124			"beginning of image.\n", i);
125			}
126			for (++i; i + 1 < frag->data_size && frag->data[i] == 0xff; i++);
127			if (i + 1 >= frag->data_size && frag->data[i]) {
128			av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
129			"no SOI marker found.\n");
130			return AVERROR_INVALIDDATA;
131			}
132			marker = frag->data[i];
133			if (marker != JPEG_MARKER_SOI) {
134			av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: first "
135			"marker is %02x, should be SOI.\n", marker);
136			return AVERROR_INVALIDDATA;
137			}
138			for (++i; i + 1 < frag->data_size && frag->data[i] == 0xff; i++);
139			if (i + 1 >= frag->data_size) {
140			av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
141			"no image content found.\n");
142			return AVERROR_INVALIDDATA;
143			}
144			marker = frag->data[i];
145			start = i + 1;
146
147			for (unit = 0;; unit++) {
148			if (marker == JPEG_MARKER_EOI) {
149			break;
150			} else if (marker == JPEG_MARKER_SOS) {
151			next_marker = -1;
152			end = start;
153			for (i = start; i + 1 < frag->data_size; i++) {
154			if (frag->data[i] != 0xff)
155			continue;
156			end = i;
157			for (++i; i + 1 < frag->data_size &&
158			frag->data[i] == 0xff; i++);
159			if (i + 1 < frag->data_size) {
160			if (frag->data[i] == 0x00)
161			continue;
162			next_marker = frag->data[i];
163			next_start = i + 1;
164			}
165			break;
166			}
167			} else {
168			i = start;
169			if (i + 2 > frag->data_size) {
170			av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
171			"truncated at %02x marker.\n", marker);
172			return AVERROR_INVALIDDATA;
173			}
174			length = AV_RB16(frag->data + i);
175			if (i + length > frag->data_size) {
176			av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
177			"truncated at %02x marker segment.\n", marker);
178			return AVERROR_INVALIDDATA;
179			}
180			end = start + length;
181
182			i = end;
183			if (frag->data[i] != 0xff) {
184			next_marker = -1;
185			} else {
186			for (++i; i + 1 < frag->data_size &&
187			frag->data[i] == 0xff; i++);
188			if (i + 1 >= frag->data_size) {
189			next_marker = -1;
190			} else {
191			next_marker = frag->data[i];
192			next_start = i + 1;
193			}
194			}
195			}
196
197			if (marker == JPEG_MARKER_SOS) {
198			length = AV_RB16(frag->data + start);
199
200			if (length > end - start)
201			return AVERROR_INVALIDDATA;
202
203			data_ref = NULL;
204			data = av_malloc(end - start +
205			AV_INPUT_BUFFER_PADDING_SIZE);
206			if (!data)
207			return AVERROR(ENOMEM);
208
209			memcpy(data, frag->data + start, length);
210			for (i = start + length, j = length; i < end; i++, j++) {
211			if (frag->data[i] == 0xff) {
212			while (frag->data[i] == 0xff)
213			++i;
214			data[j] = 0xff;
215			} else {
216			data[j] = frag->data[i];
217			}
218			}
219			data_size = j;
220
221			memset(data + data_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
222
223			} else {
224			data = frag->data + start;
225			data_size = end - start;
226			data_ref = frag->data_ref;
227			}
228
229			err = ff_cbs_insert_unit_data(frag, unit, marker,
230			data, data_size, data_ref);
231			if (err < 0)
232			return err;
233
234			if (next_marker == -1)
235			break;
236			marker = next_marker;
237			start = next_start;
238			}
239
240			return 0;
241			}
242
243			static int cbs_jpeg_read_unit(CodedBitstreamContext *ctx,
244			CodedBitstreamUnit *unit)
245			{
246			GetBitContext gbc;
247			int err;
248
249			err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
250			if (err < 0)
251			return err;
252
253			if (unit->type >= JPEG_MARKER_SOF0 &&
254			unit->type <= JPEG_MARKER_SOF3) {
255			err = ff_cbs_alloc_unit_content(unit,
256			sizeof(JPEGRawFrameHeader),
257			NULL);
258			if (err < 0)
259			return err;
260
261			err = cbs_jpeg_read_frame_header(ctx, &gbc, unit->content);
262			if (err < 0)
263			return err;
264
265			} else if (unit->type >= JPEG_MARKER_APPN &&
266			unit->type <= JPEG_MARKER_APPN + 15) {
267			err = ff_cbs_alloc_unit_content(unit,
268			sizeof(JPEGRawApplicationData),
269			&cbs_jpeg_free_application_data);
270			if (err < 0)
271			return err;
272
273			err = cbs_jpeg_read_application_data(ctx, &gbc, unit->content);
274			if (err < 0)
275			return err;
276
277			} else if (unit->type == JPEG_MARKER_SOS) {
278			JPEGRawScan *scan;
279			int pos;
280
281			err = ff_cbs_alloc_unit_content(unit,
282			sizeof(JPEGRawScan),
283			&cbs_jpeg_free_scan);
284			if (err < 0)
285			return err;
286			scan = unit->content;
287
288			err = cbs_jpeg_read_scan_header(ctx, &gbc, &scan->header);
289			if (err < 0)
290			return err;
291
292			pos = get_bits_count(&gbc);
293			av_assert0(pos % 8 == 0);
294			if (pos > 0) {
295			scan->data_size = unit->data_size - pos / 8;
296			scan->data_ref = av_buffer_ref(unit->data_ref);
297			if (!scan->data_ref)
298			return AVERROR(ENOMEM);
299			scan->data = unit->data + pos / 8;
300			}
301
302			} else {
303			switch (unit->type) {
304			#define SEGMENT(marker, type, func, free) \
305			case JPEG_MARKER_ ## marker: \
306			{ \
307			err = ff_cbs_alloc_unit_content(unit, \
308			sizeof(type), free); \
309			if (err < 0) \
310			return err; \
311			err = cbs_jpeg_read_ ## func(ctx, &gbc, unit->content); \
312			if (err < 0) \
313			return err; \
314			} \
315			break
316			SEGMENT(DQT, JPEGRawQuantisationTableSpecification, dqt, NULL);
317			SEGMENT(DHT, JPEGRawHuffmanTableSpecification, dht, NULL);
318			SEGMENT(COM, JPEGRawComment, comment, &cbs_jpeg_free_comment);
319			#undef SEGMENT
320			default:
321			return AVERROR(ENOSYS);
322			}
323			}
324
325			return 0;
326			}
327
328			static int cbs_jpeg_write_scan(CodedBitstreamContext *ctx,
329			CodedBitstreamUnit *unit,
330			PutBitContext *pbc)
331			{
332			JPEGRawScan *scan = unit->content;
333			int err;
334
335			err = cbs_jpeg_write_scan_header(ctx, pbc, &scan->header);
336			if (err < 0)
337			return err;
338
339			if (scan->data) {
340			if (scan->data_size * 8 > put_bits_left(pbc))
341			return AVERROR(ENOSPC);
342
343			av_assert0(put_bits_count(pbc) % 8 == 0);
344
345			flush_put_bits(pbc);
346
347			memcpy(put_bits_ptr(pbc), scan->data, scan->data_size);
348			skip_put_bytes(pbc, scan->data_size);
349			}
350
351			return 0;
352			}
353
354			static int cbs_jpeg_write_segment(CodedBitstreamContext *ctx,
355			CodedBitstreamUnit *unit,
356			PutBitContext *pbc)
357			{
358			int err;
359
360			if (unit->type >= JPEG_MARKER_SOF0 &&
361			unit->type <= JPEG_MARKER_SOF3) {
362			err = cbs_jpeg_write_frame_header(ctx, pbc, unit->content);
363			} else if (unit->type >= JPEG_MARKER_APPN &&
364			unit->type <= JPEG_MARKER_APPN + 15) {
365			err = cbs_jpeg_write_application_data(ctx, pbc, unit->content);
366			} else {
367			switch (unit->type) {
368			#define SEGMENT(marker, func) \
369			case JPEG_MARKER_ ## marker: \
370			err = cbs_jpeg_write_ ## func(ctx, pbc, unit->content); \
371			break;
372			SEGMENT(DQT, dqt);
373			SEGMENT(DHT, dht);
374			SEGMENT(COM, comment);
375			default:
376			return AVERROR_PATCHWELCOME;
377			}
378			}
379
380			return err;
381			}
382
383			static int cbs_jpeg_write_unit(CodedBitstreamContext *ctx,
384			CodedBitstreamUnit *unit,
385			PutBitContext *pbc)
386			{
387			if (unit->type == JPEG_MARKER_SOS)
388			return cbs_jpeg_write_scan (ctx, unit, pbc);
389			else
390			return cbs_jpeg_write_segment(ctx, unit, pbc);
391			}
392
393			static int cbs_jpeg_assemble_fragment(CodedBitstreamContext *ctx,
394			CodedBitstreamFragment *frag)
395			{
396			const CodedBitstreamUnit *unit;
397			uint8_t *data;
398			size_t size, dp, sp;
399			int i;
400
401			size = 4; // SOI + EOI.
402			for (i = 0; i < frag->nb_units; i++) {
403			unit = &frag->units[i];
404			size += 2 + unit->data_size;
405			if (unit->type == JPEG_MARKER_SOS) {
406			for (sp = 0; sp < unit->data_size; sp++) {
407			if (unit->data[sp] == 0xff)
408			++size;
409			}
410			}
411			}
412
413			frag->data_ref = av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
414			if (!frag->data_ref)
415			return AVERROR(ENOMEM);
416			data = frag->data_ref->data;
417
418			dp = 0;
419
420			data[dp++] = 0xff;
421			data[dp++] = JPEG_MARKER_SOI;
422
423			for (i = 0; i < frag->nb_units; i++) {
424			unit = &frag->units[i];
425
426			data[dp++] = 0xff;
427			data[dp++] = unit->type;
428
429			if (unit->type != JPEG_MARKER_SOS) {
430			memcpy(data + dp, unit->data, unit->data_size);
431			dp += unit->data_size;
432			} else {
433			sp = AV_RB16(unit->data);
434			av_assert0(sp <= unit->data_size);
435			memcpy(data + dp, unit->data, sp);
436			dp += sp;
437
438			for (; sp < unit->data_size; sp++) {
439			if (unit->data[sp] == 0xff) {
440			data[dp++] = 0xff;
441			data[dp++] = 0x00;
442			} else {
443			data[dp++] = unit->data[sp];
444			}
445			}
446			}
447			}
448
449			data[dp++] = 0xff;
450			data[dp++] = JPEG_MARKER_EOI;
451
452			av_assert0(dp == size);
453
454			memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
455			frag->data = data;
456			frag->data_size = size;
457
458			return 0;
459			}
460
461			const CodedBitstreamType ff_cbs_type_jpeg = {
462			.codec_id = AV_CODEC_ID_MJPEG,
463
464			.split_fragment = &cbs_jpeg_split_fragment,
465			.read_unit = &cbs_jpeg_read_unit,
466			.write_unit = &cbs_jpeg_write_unit,
467			.assemble_fragment = &cbs_jpeg_assemble_fragment,
468			};