GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/fitsenc.c Lines: 46 50 92.0 %
Date: 2019-11-18 18:00:01 Branches: 18 20 90.0 %

Line Branch Exec Source
1
/*
2
 * FITS image encoder
3
 * Copyright (c) 2017 Paras Chadha
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
/**
23
 * @file
24
 * FITS image encoder
25
 *
26
 * Specification: https://fits.gsfc.nasa.gov/fits_standard.html Version 3.0
27
 *
28
 * RGBA images are encoded as planes in RGBA order. So, NAXIS3 is 3 or 4 for them.
29
 * Also CTYPE3 = 'RGB ' is added to the header to distinguish them from 3d images.
30
 */
31
32
#include "libavutil/intreadwrite.h"
33
#include "avcodec.h"
34
#include "bytestream.h"
35
#include "internal.h"
36
37
189
static int fits_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
38
                            const AVFrame *pict, int *got_packet)
39
{
40
189
    AVFrame * const p = (AVFrame *)pict;
41
    uint8_t *bytestream, *bytestream_start, *ptr;
42
189
    const uint16_t flip = (1 << 15);
43
189
    uint64_t data_size = 0, padded_data_size = 0;
44
189
    int ret, bitpix, naxis3 = 1, i, j, k, bytes_left;
45
189
    int map[] = {2, 0, 1, 3}; // mapping from GBRA -> RGBA as RGBA is to be stored in FITS file..
46
47

189
    switch (avctx->pix_fmt) {
48
61
    case AV_PIX_FMT_GRAY8:
49
    case AV_PIX_FMT_GRAY16BE:
50
61
        map[0] = 0; // grayscale images should be directly mapped
51
61
        if (avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
52
31
            bitpix = 8;
53
        } else {
54
30
            bitpix = 16;
55
        }
56
61
        break;
57
66
    case AV_PIX_FMT_GBRP:
58
    case AV_PIX_FMT_GBRAP:
59
66
        bitpix = 8;
60
66
        if (avctx->pix_fmt == AV_PIX_FMT_GBRP) {
61
31
            naxis3 = 3;
62
        } else {
63
35
            naxis3 = 4;
64
        }
65
66
        break;
66
62
    case AV_PIX_FMT_GBRP16BE:
67
    case AV_PIX_FMT_GBRAP16BE:
68
62
        bitpix = 16;
69
62
        if (avctx->pix_fmt == AV_PIX_FMT_GBRP16BE) {
70
31
            naxis3 = 3;
71
        } else {
72
31
            naxis3 = 4;
73
        }
74
62
        break;
75
    default:
76
        av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
77
        return AVERROR(EINVAL);
78
    }
79
80
189
    data_size = (bitpix >> 3) * avctx->height * avctx->width * naxis3;
81
189
    padded_data_size = ((data_size + 2879) / 2880 ) * 2880;
82
83
189
    if ((ret = ff_alloc_packet2(avctx, pkt, padded_data_size, 0)) < 0)
84
        return ret;
85
86
189
    bytestream_start =
87
189
    bytestream       = pkt->data;
88
89
700
    for (k = 0; k < naxis3; k++) {
90
120719
        for (i = 0; i < avctx->height; i++) {
91
120208
            ptr = p->data[map[k]] + (avctx->height - i - 1) * p->linesize[map[k]];
92
120208
            if (bitpix == 16) {
93
20553504
                for (j = 0; j < avctx->width; j++) {
94
                    // subtracting bzero is equivalent to first bit flip
95
20493568
                    bytestream_put_be16(&bytestream, AV_RB16(ptr) ^ flip);
96
20493568
                    ptr += 2;
97
                }
98
            } else {
99
60272
                memcpy(bytestream, ptr, avctx->width);
100
60272
                bytestream += avctx->width;
101
            }
102
        }
103
    }
104
105
189
    bytes_left = padded_data_size - data_size;
106
189
    memset(bytestream, 0, bytes_left);
107
189
    bytestream += bytes_left;
108
109
189
    pkt->size   = bytestream - bytestream_start;
110
189
    pkt->flags |= AV_PKT_FLAG_KEY;
111
189
    *got_packet = 1;
112
113
189
    return 0;
114
}
115
116
AVCodec ff_fits_encoder = {
117
    .name           = "fits",
118
    .long_name      = NULL_IF_CONFIG_SMALL("Flexible Image Transport System"),
119
    .type           = AVMEDIA_TYPE_VIDEO,
120
    .id             = AV_CODEC_ID_FITS,
121
    .encode2        = fits_encode_frame,
122
    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_GBRAP16BE,
123
                                                     AV_PIX_FMT_GBRP16BE,
124
                                                     AV_PIX_FMT_GBRP,
125
                                                     AV_PIX_FMT_GBRAP,
126
                                                     AV_PIX_FMT_GRAY16BE,
127
                                                     AV_PIX_FMT_GRAY8,
128
                                                     AV_PIX_FMT_NONE },
129
};