Head

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/psd.c	Lines:	166	321	51.7 %
Date:	2020-01-28 04:56:05	Branches:	99	180	55.0 %


/*
 * Photoshop (PSD) image decoder
 * Copyright (c) 2016 Jokyo Images
 *
 * 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 "bytestream.h"
#include "internal.h"

enum PsdCompr {
    PSD_RAW,
    PSD_RLE,
    PSD_ZIP_WITHOUT_P,
    PSD_ZIP_WITH_P,
};

enum PsdColorMode {
    PSD_BITMAP,
    PSD_GRAYSCALE,
    PSD_INDEXED,
    PSD_RGB,
    PSD_CMYK,
    PSD_MULTICHANNEL,
    PSD_DUOTONE,
    PSD_LAB,
};

typedef struct PSDContext {
    AVClass *class;
    AVFrame *picture;
    AVCodecContext *avctx;
    GetByteContext gb;

    uint8_t * tmp;

    uint16_t channel_count;
    uint16_t channel_depth;

    uint64_t uncompressed_size;
    unsigned int pixel_size;/* 1 for 8 bits, 2 for 16 bits */
    uint64_t line_size;/* length of src data (even width) */

    int width;
    int height;

    enum PsdCompr compression;
    enum PsdColorMode color_mode;

    uint8_t palette[AVPALETTE_SIZE];
} PSDContext;

static int decode_header(PSDContext * s)
{
    int signature, version, color_mode;
    int64_t len_section;
    int ret = 0;

    if (bytestream2_get_bytes_left(&s->gb) < 30) {/* File header section + color map data section length */
        av_log(s->avctx, AV_LOG_ERROR, "Header too short to parse.\n");
        return AVERROR_INVALIDDATA;
    }

    signature = bytestream2_get_le32(&s->gb);
    if (signature != MKTAG('8','B','P','S')) {
        av_log(s->avctx, AV_LOG_ERROR, "Wrong signature %d.\n", signature);
        return AVERROR_INVALIDDATA;
    }

    version = bytestream2_get_be16(&s->gb);
    if (version != 1) {
        av_log(s->avctx, AV_LOG_ERROR, "Wrong version %d.\n", version);
        return AVERROR_INVALIDDATA;
    }

    bytestream2_skip(&s->gb, 6);/* reserved */

    s->channel_count = bytestream2_get_be16(&s->gb);
    if ((s->channel_count < 1) || (s->channel_count > 56)) {
        av_log(s->avctx, AV_LOG_ERROR, "Invalid channel count %d.\n", s->channel_count);
        return AVERROR_INVALIDDATA;
    }

    s->height = bytestream2_get_be32(&s->gb);

    if ((s->height > 30000) && (s->avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) {
        av_log(s->avctx, AV_LOG_ERROR,
               "Height > 30000 is experimental, add "
               "'-strict %d' if you want to try to decode the picture.\n",
               FF_COMPLIANCE_EXPERIMENTAL);
        return AVERROR_EXPERIMENTAL;
    }

    s->width = bytestream2_get_be32(&s->gb);
    if ((s->width > 30000) && (s->avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) {
        av_log(s->avctx, AV_LOG_ERROR,
               "Width > 30000 is experimental, add "
               "'-strict %d' if you want to try to decode the picture.\n",
               FF_COMPLIANCE_EXPERIMENTAL);
        return AVERROR_EXPERIMENTAL;
    }

    if ((ret = ff_set_dimensions(s->avctx, s->width, s->height)) < 0)
        return ret;

    s->channel_depth = bytestream2_get_be16(&s->gb);

    color_mode = bytestream2_get_be16(&s->gb);
    switch (color_mode) {
    case 0:
        s->color_mode = PSD_BITMAP;
        break;
    case 1:
        s->color_mode = PSD_GRAYSCALE;
        break;
    case 2:
        s->color_mode = PSD_INDEXED;
        break;
    case 3:
        s->color_mode = PSD_RGB;
        break;
    case 4:
        s->color_mode = PSD_CMYK;
        break;
    case 7:
        s->color_mode = PSD_MULTICHANNEL;
        break;
    case 8:
        s->color_mode = PSD_DUOTONE;
        break;
    case 9:
        s->color_mode = PSD_LAB;
        break;
    default:
        av_log(s->avctx, AV_LOG_ERROR, "Unknown color mode %d.\n", color_mode);
        return AVERROR_INVALIDDATA;
    }

    /* color map data */
    len_section = bytestream2_get_be32(&s->gb);
    if (len_section < 0) {
        av_log(s->avctx, AV_LOG_ERROR, "Negative size for color map data section.\n");
        return AVERROR_INVALIDDATA;
    }

    if (bytestream2_get_bytes_left(&s->gb) < (len_section + 4)) { /* section and len next section */
        av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n");
        return AVERROR_INVALIDDATA;
    }
    if (len_section) {
        int i,j;
        memset(s->palette, 0xff, AVPALETTE_SIZE);
        for (j = HAVE_BIGENDIAN; j < 3 + HAVE_BIGENDIAN; j++)
            for (i = 0; i < FFMIN(256, len_section / 3); i++)
                s->palette[i * 4 + (HAVE_BIGENDIAN ? j : 2 - j)] = bytestream2_get_byteu(&s->gb);
        len_section -= i * 3;
    }
    bytestream2_skip(&s->gb, len_section);

    /* image ressources */
    len_section = bytestream2_get_be32(&s->gb);
    if (len_section < 0) {
        av_log(s->avctx, AV_LOG_ERROR, "Negative size for image ressources section.\n");
        return AVERROR_INVALIDDATA;
    }

    if (bytestream2_get_bytes_left(&s->gb) < (len_section + 4)) { /* section and len next section */
        av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n");
        return AVERROR_INVALIDDATA;
    }
    bytestream2_skip(&s->gb, len_section);

    /* layers and masks */
    len_section = bytestream2_get_be32(&s->gb);
    if (len_section < 0) {
        av_log(s->avctx, AV_LOG_ERROR, "Negative size for layers and masks data section.\n");
        return AVERROR_INVALIDDATA;
    }

    if (bytestream2_get_bytes_left(&s->gb) < len_section) {
        av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n");
        return AVERROR_INVALIDDATA;
    }
    bytestream2_skip(&s->gb, len_section);

    /* image section */
    if (bytestream2_get_bytes_left(&s->gb) < 2) {
        av_log(s->avctx, AV_LOG_ERROR, "File without image data section.\n");
        return AVERROR_INVALIDDATA;
    }

    s->compression = bytestream2_get_be16(&s->gb);
    switch (s->compression) {
    case 0:
    case 1:
        break;
    case 2:
        avpriv_request_sample(s->avctx, "ZIP without predictor compression");
        return AVERROR_PATCHWELCOME;
    case 3:
        avpriv_request_sample(s->avctx, "ZIP with predictor compression");
        return AVERROR_PATCHWELCOME;
    default:
        av_log(s->avctx, AV_LOG_ERROR, "Unknown compression %d.\n", s->compression);
        return AVERROR_INVALIDDATA;
    }

    return ret;
}

static int decode_rle(PSDContext * s){
    unsigned int scanline_count;
    unsigned int sl, count;
    unsigned long target_index = 0;
    unsigned int p;
    int8_t rle_char;
    unsigned int repeat_count;
    uint8_t v;

    scanline_count = s->height * s->channel_count;

    /* scanline table */
    if (bytestream2_get_bytes_left(&s->gb) < scanline_count * 2) {
        av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline table.\n");
        return AVERROR_INVALIDDATA;
    }
    bytestream2_skip(&s->gb, scanline_count * 2);/* size of each scanline */

    /* decode rle data scanline by scanline */
    for (sl = 0; sl < scanline_count; sl++) {
        count = 0;

        while (count < s->line_size) {
            rle_char = bytestream2_get_byte(&s->gb);

            if (rle_char <= 0) {/* byte repeat */
                repeat_count = rle_char * -1;

                if (bytestream2_get_bytes_left(&s->gb) < 1) {
                    av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline.\n");
                    return AVERROR_INVALIDDATA;
                }

                if (target_index + repeat_count >= s->uncompressed_size) {
                    av_log(s->avctx, AV_LOG_ERROR, "Invalid rle char.\n");
                    return AVERROR_INVALIDDATA;
                }

                v = bytestream2_get_byte(&s->gb);
                for (p = 0; p <= repeat_count; p++) {
                    s->tmp[target_index++] = v;
                }
                count += repeat_count + 1;
            } else {
                if (bytestream2_get_bytes_left(&s->gb) < rle_char) {
                    av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline.\n");
                    return AVERROR_INVALIDDATA;
                }

                if (target_index + rle_char >= s->uncompressed_size) {
                    av_log(s->avctx, AV_LOG_ERROR, "Invalid rle char.\n");
                    return AVERROR_INVALIDDATA;
                }

                for (p = 0; p <= rle_char; p++) {
                    v = bytestream2_get_byte(&s->gb);
                    s->tmp[target_index++] = v;
                }
                count += rle_char + 1;
            }
        }
    }

    return 0;
}

static int decode_frame(AVCodecContext *avctx, void *data,
                        int *got_frame, AVPacket *avpkt)
{
    int ret;
    uint8_t *ptr;
    const uint8_t *ptr_data;
    int index_out, c, y, x, p;
    uint8_t eq_channel[4] = {2,0,1,3};/* RGBA -> GBRA channel order */
    uint8_t plane_number;

    AVFrame *picture = data;

    PSDContext *s = avctx->priv_data;
    s->avctx     = avctx;
    s->channel_count = 0;
    s->channel_depth = 0;
    s->tmp           = NULL;
    s->line_size     = 0;

    bytestream2_init(&s->gb, avpkt->data, avpkt->size);

    if ((ret = decode_header(s)) < 0)
        return ret;

    s->pixel_size = s->channel_depth >> 3;/* in byte */
    s->line_size = s->width * s->pixel_size;

    switch (s->color_mode) {
    case PSD_BITMAP:
        if (s->channel_depth != 1 || s->channel_count != 1) {
            av_log(s->avctx, AV_LOG_ERROR,
                    "Invalid bitmap file (channel_depth %d, channel_count %d)\n",
                    s->channel_depth, s->channel_count);
            return AVERROR_INVALIDDATA;
        }
        s->line_size = s->width + 7 >> 3;
        avctx->pix_fmt = AV_PIX_FMT_MONOWHITE;
        break;
    case PSD_INDEXED:
        if (s->channel_depth != 8 || s->channel_count != 1) {
            av_log(s->avctx, AV_LOG_ERROR,
                   "Invalid indexed file (channel_depth %d, channel_count %d)\n",
                   s->channel_depth, s->channel_count);
            return AVERROR_INVALIDDATA;
        }
        avctx->pix_fmt = AV_PIX_FMT_PAL8;
        break;
    case PSD_CMYK:
        if (s->channel_count == 4) {
            if (s->channel_depth == 8) {
                avctx->pix_fmt = AV_PIX_FMT_GBRP;
            } else if (s->channel_depth == 16) {
                avctx->pix_fmt = AV_PIX_FMT_GBRP16BE;
            } else {
                avpriv_report_missing_feature(avctx, "channel depth %d for cmyk", s->channel_depth);
                return AVERROR_PATCHWELCOME;
            }
        } else if (s->channel_count == 5) {
            if (s->channel_depth == 8) {
                avctx->pix_fmt = AV_PIX_FMT_GBRAP;
            } else if (s->channel_depth == 16) {
                avctx->pix_fmt = AV_PIX_FMT_GBRAP16BE;
            } else {
                avpriv_report_missing_feature(avctx, "channel depth %d for cmyk", s->channel_depth);
                return AVERROR_PATCHWELCOME;
            }
        } else {
            avpriv_report_missing_feature(avctx, "channel count %d for cmyk", s->channel_count);
            return AVERROR_PATCHWELCOME;
        }
        break;
    case PSD_RGB:
        if (s->channel_count == 3) {
            if (s->channel_depth == 8) {
                avctx->pix_fmt = AV_PIX_FMT_GBRP;
            } else if (s->channel_depth == 16) {
                avctx->pix_fmt = AV_PIX_FMT_GBRP16BE;
            } else {
                avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth);
                return AVERROR_PATCHWELCOME;
            }
        } else if (s->channel_count == 4) {
            if (s->channel_depth == 8) {
                avctx->pix_fmt = AV_PIX_FMT_GBRAP;
            } else if (s->channel_depth == 16) {
                avctx->pix_fmt = AV_PIX_FMT_GBRAP16BE;
            } else {
                avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth);
                return AVERROR_PATCHWELCOME;
            }
        } else {
            avpriv_report_missing_feature(avctx, "channel count %d for rgb", s->channel_count);
            return AVERROR_PATCHWELCOME;
        }
        break;
    case PSD_DUOTONE:
        av_log(avctx, AV_LOG_WARNING, "ignoring unknown duotone specification.\n");
    case PSD_GRAYSCALE:
        if (s->channel_count == 1) {
            if (s->channel_depth == 8) {
                avctx->pix_fmt = AV_PIX_FMT_GRAY8;
            } else if (s->channel_depth == 16) {
                avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
            } else if (s->channel_depth == 32) {
                avctx->pix_fmt = AV_PIX_FMT_GRAYF32BE;
            } else {
                avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
                return AVERROR_PATCHWELCOME;
            }
        } else if (s->channel_count == 2) {
            if (s->channel_depth == 8) {
                avctx->pix_fmt = AV_PIX_FMT_YA8;
            } else if (s->channel_depth == 16) {
                avctx->pix_fmt = AV_PIX_FMT_YA16BE;
            } else {
                avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
                return AVERROR_PATCHWELCOME;
            }
        } else {
            avpriv_report_missing_feature(avctx, "channel count %d for grayscale", s->channel_count);
            return AVERROR_PATCHWELCOME;
        }
        break;
    default:
        avpriv_report_missing_feature(avctx, "color mode %d", s->color_mode);
        return AVERROR_PATCHWELCOME;
    }

    s->uncompressed_size = s->line_size * s->height * s->channel_count;

    if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
        return ret;

    /* decode picture if need */
    if (s->compression == PSD_RLE) {
        s->tmp = av_malloc(s->uncompressed_size);
        if (!s->tmp)
            return AVERROR(ENOMEM);

        ret = decode_rle(s);

        if (ret < 0) {
            av_freep(&s->tmp);
            return ret;
        }

        ptr_data = s->tmp;
    } else {
        if (bytestream2_get_bytes_left(&s->gb) < s->uncompressed_size) {
            av_log(s->avctx, AV_LOG_ERROR, "Not enough data for raw image data section.\n");
            return AVERROR_INVALIDDATA;
        }
        ptr_data = s->gb.buffer;
    }

    /* Store data */
    if ((avctx->pix_fmt == AV_PIX_FMT_YA8)||(avctx->pix_fmt == AV_PIX_FMT_YA16BE)){/* Interleaved */
        ptr = picture->data[0];
        for (c = 0; c < s->channel_count; c++) {
            for (y = 0; y < s->height; y++) {
                for (x = 0; x < s->width; x++) {
                    index_out = y * picture->linesize[0] + x * s->channel_count * s->pixel_size + c * s->pixel_size;
                    for (p = 0; p < s->pixel_size; p++) {
                        ptr[index_out + p] = *ptr_data;
                        ptr_data ++;
                    }
                }
            }
        }
    } else if (s->color_mode == PSD_CMYK) {
        uint8_t *dst[4] = { picture->data[0], picture->data[1], picture->data[2], picture->data[3] };
        const uint8_t *src[5] = { ptr_data };
        src[1] = src[0] + s->line_size * s->height;
        src[2] = src[1] + s->line_size * s->height;
        src[3] = src[2] + s->line_size * s->height;
        src[4] = src[3] + s->line_size * s->height;
        if (s->channel_depth == 8) {
            for (y = 0; y < s->height; y++) {
                for (x = 0; x < s->width; x++) {
                    int k = src[3][x];
                    int r = src[0][x] * k;
                    int g = src[1][x] * k;
                    int b = src[2][x] * k;
                    dst[0][x] = g * 257 >> 16;
                    dst[1][x] = b * 257 >> 16;
                    dst[2][x] = r * 257 >> 16;
                }
                dst[0] += picture->linesize[0];
                dst[1] += picture->linesize[1];
                dst[2] += picture->linesize[2];
                src[0] += s->line_size;
                src[1] += s->line_size;
                src[2] += s->line_size;
                src[3] += s->line_size;
            }
            if (avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
                for (y = 0; y < s->height; y++) {
                    memcpy(dst[3], src[4], s->line_size);
                    src[4] += s->line_size;
                    dst[3] += picture->linesize[3];
                }
            }
        } else {
            for (y = 0; y < s->height; y++) {
                for (x = 0; x < s->width; x++) {
                    int64_t k = AV_RB16(&src[3][x * 2]);
                    int64_t r = AV_RB16(&src[0][x * 2]) * k;
                    int64_t g = AV_RB16(&src[1][x * 2]) * k;
                    int64_t b = AV_RB16(&src[2][x * 2]) * k;
                    AV_WB16(&dst[0][x * 2], g * 65537 >> 32);
                    AV_WB16(&dst[1][x * 2], b * 65537 >> 32);
                    AV_WB16(&dst[2][x * 2], r * 65537 >> 32);
                }
                dst[0] += picture->linesize[0];
                dst[1] += picture->linesize[1];
                dst[2] += picture->linesize[2];
                src[0] += s->line_size;
                src[1] += s->line_size;
                src[2] += s->line_size;
                src[3] += s->line_size;
            }
            if (avctx->pix_fmt == AV_PIX_FMT_GBRAP16BE) {
                for (y = 0; y < s->height; y++) {
                    memcpy(dst[3], src[4], s->line_size);
                    src[4] += s->line_size;
                    dst[3] += picture->linesize[3];
                }
            }
        }
    } else {/* Planar */
        if (s->channel_count == 1)/* gray 8 or gray 16be */
            eq_channel[0] = 0;/* assign first channel, to first plane */

        for (c = 0; c < s->channel_count; c++) {
            plane_number = eq_channel[c];
            ptr = picture->data[plane_number];/* get the right plane */
            for (y = 0; y < s->height; y++) {
                memcpy(ptr, ptr_data, s->line_size);
                ptr += picture->linesize[plane_number];
                ptr_data += s->line_size;
            }
        }
    }

    if (s->color_mode == PSD_INDEXED) {
        picture->palette_has_changed = 1;
        memcpy(picture->data[1], s->palette, AVPALETTE_SIZE);
    }

    av_freep(&s->tmp);

    picture->pict_type = AV_PICTURE_TYPE_I;
    *got_frame = 1;

    return avpkt->size;
}

AVCodec ff_psd_decoder = {
    .name             = "psd",
    .long_name        = NULL_IF_CONFIG_SMALL("Photoshop PSD file"),
    .type             = AVMEDIA_TYPE_VIDEO,
    .id               = AV_CODEC_ID_PSD,
    .priv_data_size   = sizeof(PSDContext),
    .decode           = decode_frame,
    .capabilities     = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
};


Generated by: GCOVR (Version 4.1)

Line	Branch	Exec	Source
1			/*
2			* Photoshop (PSD) image decoder
3			* Copyright (c) 2016 Jokyo Images
4			*
5			* This file is part of FFmpeg.
6			*
7			* FFmpeg is free software; you can redistribute it and/or
8			* modify it under the terms of the GNU Lesser General Public
9			* License as published by the Free Software Foundation; either
10			* version 2.1 of the License, or (at your option) any later version.
11			*
12			* FFmpeg is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15			* Lesser General Public License for more details.
16			*
17			* You should have received a copy of the GNU Lesser General Public
18			* License along with FFmpeg; if not, write to the Free Software
19			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20			*/
21
22			#include "bytestream.h"
23			#include "internal.h"
24
25			enum PsdCompr {
26			PSD_RAW,
27			PSD_RLE,
28			PSD_ZIP_WITHOUT_P,
29			PSD_ZIP_WITH_P,
30			};
31
32			enum PsdColorMode {
33			PSD_BITMAP,
34			PSD_GRAYSCALE,
35			PSD_INDEXED,
36			PSD_RGB,
37			PSD_CMYK,
38			PSD_MULTICHANNEL,
39			PSD_DUOTONE,
40			PSD_LAB,
41			};
42
43			typedef struct PSDContext {
44			AVClass *class;
45			AVFrame *picture;
46			AVCodecContext *avctx;
47			GetByteContext gb;
48
49			uint8_t * tmp;
50
51			uint16_t channel_count;
52			uint16_t channel_depth;
53
54			uint64_t uncompressed_size;
55			unsigned int pixel_size;/* 1 for 8 bits, 2 for 16 bits */
56			uint64_t line_size;/* length of src data (even width) */
57
58			int width;
59			int height;
60
61			enum PsdCompr compression;
62			enum PsdColorMode color_mode;
63
64			uint8_t palette[AVPALETTE_SIZE];
65			} PSDContext;
66
67		30	static int decode_header(PSDContext * s)
68			{
69			int signature, version, color_mode;
70			int64_t len_section;
71		30	int ret = 0;
72
73	✗✓	30	if (bytestream2_get_bytes_left(&s->gb) < 30) {/* File header section + color map data section length */
74			av_log(s->avctx, AV_LOG_ERROR, "Header too short to parse.\n");
75			return AVERROR_INVALIDDATA;
76			}
77
78		30	signature = bytestream2_get_le32(&s->gb);
79	✗✓	30	if (signature != MKTAG('8','B','P','S')) {
80			av_log(s->avctx, AV_LOG_ERROR, "Wrong signature %d.\n", signature);
81			return AVERROR_INVALIDDATA;
82			}
83
84		30	version = bytestream2_get_be16(&s->gb);
85	✗✓	30	if (version != 1) {
86			av_log(s->avctx, AV_LOG_ERROR, "Wrong version %d.\n", version);
87			return AVERROR_INVALIDDATA;
88			}
89
90		30	bytestream2_skip(&s->gb, 6);/* reserved */
91
92		30	s->channel_count = bytestream2_get_be16(&s->gb);
93	✓✗✗✓	30	if ((s->channel_count < 1) \|\| (s->channel_count > 56)) {
94			av_log(s->avctx, AV_LOG_ERROR, "Invalid channel count %d.\n", s->channel_count);
95			return AVERROR_INVALIDDATA;
96			}
97
98		30	s->height = bytestream2_get_be32(&s->gb);
99
100	✗✓✗✗	30	if ((s->height > 30000) && (s->avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) {
101			av_log(s->avctx, AV_LOG_ERROR,
102			"Height > 30000 is experimental, add "
103			"'-strict %d' if you want to try to decode the picture.\n",
104			FF_COMPLIANCE_EXPERIMENTAL);
105			return AVERROR_EXPERIMENTAL;
106			}
107
108		30	s->width = bytestream2_get_be32(&s->gb);
109	✗✓✗✗	30	if ((s->width > 30000) && (s->avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) {
110			av_log(s->avctx, AV_LOG_ERROR,
111			"Width > 30000 is experimental, add "
112			"'-strict %d' if you want to try to decode the picture.\n",
113			FF_COMPLIANCE_EXPERIMENTAL);
114			return AVERROR_EXPERIMENTAL;
115			}
116
117	✗✓	30	if ((ret = ff_set_dimensions(s->avctx, s->width, s->height)) < 0)
118			return ret;
119
120		30	s->channel_depth = bytestream2_get_be16(&s->gb);
121
122		30	color_mode = bytestream2_get_be16(&s->gb);
123	✓✓✓✓ ✗✗✓✗ ✗	30	switch (color_mode) {
124		2	case 0:
125		2	s->color_mode = PSD_BITMAP;
126		2	break;
127		8	case 1:
128		8	s->color_mode = PSD_GRAYSCALE;
129		8	break;
130		2	case 2:
131		2	s->color_mode = PSD_INDEXED;
132		2	break;
133		16	case 3:
134		16	s->color_mode = PSD_RGB;
135		16	break;
136			case 4:
137			s->color_mode = PSD_CMYK;
138			break;
139			case 7:
140			s->color_mode = PSD_MULTICHANNEL;
141			break;
142		2	case 8:
143		2	s->color_mode = PSD_DUOTONE;
144		2	break;
145			case 9:
146			s->color_mode = PSD_LAB;
147			break;
148			default:
149			av_log(s->avctx, AV_LOG_ERROR, "Unknown color mode %d.\n", color_mode);
150			return AVERROR_INVALIDDATA;
151			}
152
153			/* color map data */
154		30	len_section = bytestream2_get_be32(&s->gb);
155	✗✓	30	if (len_section < 0) {
156			av_log(s->avctx, AV_LOG_ERROR, "Negative size for color map data section.\n");
157			return AVERROR_INVALIDDATA;
158			}
159
160	✗✓	30	if (bytestream2_get_bytes_left(&s->gb) < (len_section + 4)) { /* section and len next section */
161			av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n");
162			return AVERROR_INVALIDDATA;
163			}
164	✓✓	30	if (len_section) {
165			int i,j;
166		4	memset(s->palette, 0xff, AVPALETTE_SIZE);
167	✓✓	16	for (j = HAVE_BIGENDIAN; j < 3 + HAVE_BIGENDIAN; j++)
168	✓✓✓✓	2592	for (i = 0; i < FFMIN(256, len_section / 3); i++)
169		2580	s->palette[i * 4 + (HAVE_BIGENDIAN ? j : 2 - j)] = bytestream2_get_byteu(&s->gb);
170		4	len_section -= i * 3;
171			}
172		30	bytestream2_skip(&s->gb, len_section);
173
174			/* image ressources */
175		30	len_section = bytestream2_get_be32(&s->gb);
176	✗✓	30	if (len_section < 0) {
177			av_log(s->avctx, AV_LOG_ERROR, "Negative size for image ressources section.\n");
178			return AVERROR_INVALIDDATA;
179			}
180
181	✗✓	30	if (bytestream2_get_bytes_left(&s->gb) < (len_section + 4)) { /* section and len next section */
182			av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n");
183			return AVERROR_INVALIDDATA;
184			}
185		30	bytestream2_skip(&s->gb, len_section);
186
187			/* layers and masks */
188		30	len_section = bytestream2_get_be32(&s->gb);
189	✗✓	30	if (len_section < 0) {
190			av_log(s->avctx, AV_LOG_ERROR, "Negative size for layers and masks data section.\n");
191			return AVERROR_INVALIDDATA;
192			}
193
194	✗✓	30	if (bytestream2_get_bytes_left(&s->gb) < len_section) {
195			av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n");
196			return AVERROR_INVALIDDATA;
197			}
198		30	bytestream2_skip(&s->gb, len_section);
199
200			/* image section */
201	✗✓	30	if (bytestream2_get_bytes_left(&s->gb) < 2) {
202			av_log(s->avctx, AV_LOG_ERROR, "File without image data section.\n");
203			return AVERROR_INVALIDDATA;
204			}
205
206		30	s->compression = bytestream2_get_be16(&s->gb);
207	✓✗✗✗	30	switch (s->compression) {
208		30	case 0:
209			case 1:
210		30	break;
211			case 2:
212			avpriv_request_sample(s->avctx, "ZIP without predictor compression");
213			return AVERROR_PATCHWELCOME;
214			case 3:
215			avpriv_request_sample(s->avctx, "ZIP with predictor compression");
216			return AVERROR_PATCHWELCOME;
217			default:
218			av_log(s->avctx, AV_LOG_ERROR, "Unknown compression %d.\n", s->compression);
219			return AVERROR_INVALIDDATA;
220			}
221
222		30	return ret;
223			}
224
225		8	static int decode_rle(PSDContext * s){
226			unsigned int scanline_count;
227			unsigned int sl, count;
228		8	unsigned long target_index = 0;
229			unsigned int p;
230			int8_t rle_char;
231			unsigned int repeat_count;
232			uint8_t v;
233
234		8	scanline_count = s->height * s->channel_count;
235
236			/* scanline table */
237	✗✓	8	if (bytestream2_get_bytes_left(&s->gb) < scanline_count * 2) {
238			av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline table.\n");
239			return AVERROR_INVALIDDATA;
240			}
241		8	bytestream2_skip(&s->gb, scanline_count * 2);/* size of each scanline */
242
243			/* decode rle data scanline by scanline */
244	✓✓	2812	for (sl = 0; sl < scanline_count; sl++) {
245		2804	count = 0;
246
247	✓✓	21344	while (count < s->line_size) {
248		18540	rle_char = bytestream2_get_byte(&s->gb);
249
250	✓✓	18540	if (rle_char <= 0) {/* byte repeat */
251		12340	repeat_count = rle_char * -1;
252
253	✗✓	12340	if (bytestream2_get_bytes_left(&s->gb) < 1) {
254			av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline.\n");
255			return AVERROR_INVALIDDATA;
256			}
257
258	✗✓	12340	if (target_index + repeat_count >= s->uncompressed_size) {
259			av_log(s->avctx, AV_LOG_ERROR, "Invalid rle char.\n");
260			return AVERROR_INVALIDDATA;
261			}
262
263		12340	v = bytestream2_get_byte(&s->gb);
264	✓✓	222692	for (p = 0; p <= repeat_count; p++) {
265		210352	s->tmp[target_index++] = v;
266			}
267		12340	count += repeat_count + 1;
268			} else {
269	✗✓	6200	if (bytestream2_get_bytes_left(&s->gb) < rle_char) {
270			av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline.\n");
271			return AVERROR_INVALIDDATA;
272			}
273
274	✗✓	6200	if (target_index + rle_char >= s->uncompressed_size) {
275			av_log(s->avctx, AV_LOG_ERROR, "Invalid rle char.\n");
276			return AVERROR_INVALIDDATA;
277			}
278
279	✓✓	250010	for (p = 0; p <= rle_char; p++) {
280		243810	v = bytestream2_get_byte(&s->gb);
281		243810	s->tmp[target_index++] = v;
282			}
283		6200	count += rle_char + 1;
284			}
285			}
286			}
287
288		8	return 0;
289			}
290
291		30	static int decode_frame(AVCodecContext avctx, void data,
292			int got_frame, AVPacket avpkt)
293			{
294			int ret;
295			uint8_t *ptr;
296			const uint8_t *ptr_data;
297			int index_out, c, y, x, p;
298		30	uint8_t eq_channel[4] = {2,0,1,3};/* RGBA -> GBRA channel order */
299			uint8_t plane_number;
300
301		30	AVFrame *picture = data;
302
303		30	PSDContext *s = avctx->priv_data;
304		30	s->avctx = avctx;
305		30	s->channel_count = 0;
306		30	s->channel_depth = 0;
307		30	s->tmp = NULL;
308		30	s->line_size = 0;
309
310		30	bytestream2_init(&s->gb, avpkt->data, avpkt->size);
311
312	✗✓	30	if ((ret = decode_header(s)) < 0)
313			return ret;
314
315		30	s->pixel_size = s->channel_depth >> 3;/* in byte */
316		30	s->line_size = s->width * s->pixel_size;
317
318	✓✓✗✓ ✓✓✗	30	switch (s->color_mode) {
319		2	case PSD_BITMAP:
320	✓✗✗✓	2	if (s->channel_depth != 1 \|\| s->channel_count != 1) {
321			av_log(s->avctx, AV_LOG_ERROR,
322			"Invalid bitmap file (channel_depth %d, channel_count %d)\n",
323			s->channel_depth, s->channel_count);
324			return AVERROR_INVALIDDATA;
325			}
326		2	s->line_size = s->width + 7 >> 3;
327		2	avctx->pix_fmt = AV_PIX_FMT_MONOWHITE;
328		2	break;
329		2	case PSD_INDEXED:
330	✓✗✗✓	2	if (s->channel_depth != 8 \|\| s->channel_count != 1) {
331			av_log(s->avctx, AV_LOG_ERROR,
332			"Invalid indexed file (channel_depth %d, channel_count %d)\n",
333			s->channel_depth, s->channel_count);
334			return AVERROR_INVALIDDATA;
335			}
336		2	avctx->pix_fmt = AV_PIX_FMT_PAL8;
337		2	break;
338			case PSD_CMYK:
339			if (s->channel_count == 4) {
340			if (s->channel_depth == 8) {
341			avctx->pix_fmt = AV_PIX_FMT_GBRP;
342			} else if (s->channel_depth == 16) {
343			avctx->pix_fmt = AV_PIX_FMT_GBRP16BE;
344			} else {
345			avpriv_report_missing_feature(avctx, "channel depth %d for cmyk", s->channel_depth);
346			return AVERROR_PATCHWELCOME;
347			}
348			} else if (s->channel_count == 5) {
349			if (s->channel_depth == 8) {
350			avctx->pix_fmt = AV_PIX_FMT_GBRAP;
351			} else if (s->channel_depth == 16) {
352			avctx->pix_fmt = AV_PIX_FMT_GBRAP16BE;
353			} else {
354			avpriv_report_missing_feature(avctx, "channel depth %d for cmyk", s->channel_depth);
355			return AVERROR_PATCHWELCOME;
356			}
357			} else {
358			avpriv_report_missing_feature(avctx, "channel count %d for cmyk", s->channel_count);
359			return AVERROR_PATCHWELCOME;
360			}
361			break;
362		16	case PSD_RGB:
363	✓✓	16	if (s->channel_count == 3) {
364	✓✓	10	if (s->channel_depth == 8) {
365		6	avctx->pix_fmt = AV_PIX_FMT_GBRP;
366	✓✗	4	} else if (s->channel_depth == 16) {
367		4	avctx->pix_fmt = AV_PIX_FMT_GBRP16BE;
368			} else {
369			avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth);
370			return AVERROR_PATCHWELCOME;
371			}
372	✓✗	6	} else if (s->channel_count == 4) {
373	✓✓	6	if (s->channel_depth == 8) {
374		4	avctx->pix_fmt = AV_PIX_FMT_GBRAP;
375	✓✗	2	} else if (s->channel_depth == 16) {
376		2	avctx->pix_fmt = AV_PIX_FMT_GBRAP16BE;
377			} else {
378			avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth);
379			return AVERROR_PATCHWELCOME;
380			}
381			} else {
382			avpriv_report_missing_feature(avctx, "channel count %d for rgb", s->channel_count);
383			return AVERROR_PATCHWELCOME;
384			}
385		16	break;
386		2	case PSD_DUOTONE:
387		2	av_log(avctx, AV_LOG_WARNING, "ignoring unknown duotone specification.\n");
388		10	case PSD_GRAYSCALE:
389	✓✓	10	if (s->channel_count == 1) {
390	✓✓	6	if (s->channel_depth == 8) {
391		4	avctx->pix_fmt = AV_PIX_FMT_GRAY8;
392	✓✗	2	} else if (s->channel_depth == 16) {
393		2	avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
394			} else if (s->channel_depth == 32) {
395			avctx->pix_fmt = AV_PIX_FMT_GRAYF32BE;
396			} else {
397			avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
398			return AVERROR_PATCHWELCOME;
399			}
400	✓✗	4	} else if (s->channel_count == 2) {
401	✓✓	4	if (s->channel_depth == 8) {
402		2	avctx->pix_fmt = AV_PIX_FMT_YA8;
403	✓✗	2	} else if (s->channel_depth == 16) {
404		2	avctx->pix_fmt = AV_PIX_FMT_YA16BE;
405			} else {
406			avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
407			return AVERROR_PATCHWELCOME;
408			}
409			} else {
410			avpriv_report_missing_feature(avctx, "channel count %d for grayscale", s->channel_count);
411			return AVERROR_PATCHWELCOME;
412			}
413		10	break;
414			default:
415			avpriv_report_missing_feature(avctx, "color mode %d", s->color_mode);
416			return AVERROR_PATCHWELCOME;
417			}
418
419		30	s->uncompressed_size = s->line_size * s->height * s->channel_count;
420
421	✗✓	30	if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
422			return ret;
423
424			/* decode picture if need */
425	✓✓	30	if (s->compression == PSD_RLE) {
426		8	s->tmp = av_malloc(s->uncompressed_size);
427	✗✓	8	if (!s->tmp)
428			return AVERROR(ENOMEM);
429
430		8	ret = decode_rle(s);
431
432	✗✓	8	if (ret < 0) {
433			av_freep(&s->tmp);
434			return ret;
435			}
436
437		8	ptr_data = s->tmp;
438			} else {
439	✗✓	22	if (bytestream2_get_bytes_left(&s->gb) < s->uncompressed_size) {
440			av_log(s->avctx, AV_LOG_ERROR, "Not enough data for raw image data section.\n");
441			return AVERROR_INVALIDDATA;
442			}
443		22	ptr_data = s->gb.buffer;
444			}
445
446			/* Store data */
447	✓✓✓✓	30	if ((avctx->pix_fmt == AV_PIX_FMT_YA8)\|\|(avctx->pix_fmt == AV_PIX_FMT_YA16BE)){/* Interleaved */
448		4	ptr = picture->data[0];
449	✓✓	12	for (c = 0; c < s->channel_count; c++) {
450	✓✓	1032	for (y = 0; y < s->height; y++) {
451	✓✓	132096	for (x = 0; x < s->width; x++) {
452		131072	index_out = y * picture->linesize[0] + x * s->channel_count * s->pixel_size + c * s->pixel_size;
453	✓✓	327680	for (p = 0; p < s->pixel_size; p++) {
454		196608	ptr[index_out + p] = *ptr_data;
455		196608	ptr_data ++;
456			}
457			}
458			}
459			}
460	✗✓	26	} else if (s->color_mode == PSD_CMYK) {
461			uint8_t *dst[4] = { picture->data[0], picture->data[1], picture->data[2], picture->data[3] };
462			const uint8_t *src[5] = { ptr_data };
463			src[1] = src[0] + s->line_size * s->height;
464			src[2] = src[1] + s->line_size * s->height;
465			src[3] = src[2] + s->line_size * s->height;
466			src[4] = src[3] + s->line_size * s->height;
467			if (s->channel_depth == 8) {
468			for (y = 0; y < s->height; y++) {
469			for (x = 0; x < s->width; x++) {
470			int k = src[3][x];
471			int r = src[0][x] * k;
472			int g = src[1][x] * k;
473			int b = src[2][x] * k;
474			dst[0][x] = g * 257 >> 16;
475			dst[1][x] = b * 257 >> 16;
476			dst[2][x] = r * 257 >> 16;
477			}
478			dst[0] += picture->linesize[0];
479			dst[1] += picture->linesize[1];
480			dst[2] += picture->linesize[2];
481			src[0] += s->line_size;
482			src[1] += s->line_size;
483			src[2] += s->line_size;
484			src[3] += s->line_size;
485			}
486			if (avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
487			for (y = 0; y < s->height; y++) {
488			memcpy(dst[3], src[4], s->line_size);
489			src[4] += s->line_size;
490			dst[3] += picture->linesize[3];
491			}
492			}
493			} else {
494			for (y = 0; y < s->height; y++) {
495			for (x = 0; x < s->width; x++) {
496			int64_t k = AV_RB16(&src[3][x * 2]);
497			int64_t r = AV_RB16(&src[0][x * 2]) * k;
498			int64_t g = AV_RB16(&src[1][x * 2]) * k;
499			int64_t b = AV_RB16(&src[2][x * 2]) * k;
500			AV_WB16(&dst[0][x * 2], g * 65537 >> 32);
501			AV_WB16(&dst[1][x * 2], b * 65537 >> 32);
502			AV_WB16(&dst[2][x * 2], r * 65537 >> 32);
503			}
504			dst[0] += picture->linesize[0];
505			dst[1] += picture->linesize[1];
506			dst[2] += picture->linesize[2];
507			src[0] += s->line_size;
508			src[1] += s->line_size;
509			src[2] += s->line_size;
510			src[3] += s->line_size;
511			}
512			if (avctx->pix_fmt == AV_PIX_FMT_GBRAP16BE) {
513			for (y = 0; y < s->height; y++) {
514			memcpy(dst[3], src[4], s->line_size);
515			src[4] += s->line_size;
516			dst[3] += picture->linesize[3];
517			}
518			}
519			}
520			} else {/* Planar */
521	✓✓	26	if (s->channel_count == 1)/* gray 8 or gray 16be */
522		10	eq_channel[0] = 0;/* assign first channel, to first plane */
523
524	✓✓	90	for (c = 0; c < s->channel_count; c++) {
525		64	plane_number = eq_channel[c];
526		64	ptr = picture->data[plane_number];/* get the right plane */
527	✓✓	8238	for (y = 0; y < s->height; y++) {
528		8174	memcpy(ptr, ptr_data, s->line_size);
529		8174	ptr += picture->linesize[plane_number];
530		8174	ptr_data += s->line_size;
531			}
532			}
533			}
534
535	✓✓	30	if (s->color_mode == PSD_INDEXED) {
536		2	picture->palette_has_changed = 1;
537		2	memcpy(picture->data[1], s->palette, AVPALETTE_SIZE);
538			}
539
540		30	av_freep(&s->tmp);
541
542		30	picture->pict_type = AV_PICTURE_TYPE_I;
543		30	*got_frame = 1;
544
545		30	return avpkt->size;
546			}
547
548			AVCodec ff_psd_decoder = {
549			.name = "psd",
550			.long_name = NULL_IF_CONFIG_SMALL("Photoshop PSD file"),
551			.type = AVMEDIA_TYPE_VIDEO,
552			.id = AV_CODEC_ID_PSD,
553			.priv_data_size = sizeof(PSDContext),
554			.decode = decode_frame,
555			.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_FRAME_THREADS,
556			};