[deb_ffmpeg.git] / ffmpeg / libavformat / cinedec.c

/*
 * Phantom Cine demuxer
 * Copyright (c) 2010-2011 Peter Ross <pross@xvid.org>
 *
 * 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
 */

/**
 * @file
 * Phantom Cine demuxer
 * @author Peter Ross <pross@xvid.org>
 */

#include "libavutil/intreadwrite.h"
#include "libavcodec/bmp.h"
#include "libavutil/intfloat.h"
#include "avformat.h"
#include "internal.h"

typedef struct {
    uint64_t pts;
} CineDemuxContext;

/** Compression */
enum {
    CC_RGB   = 0,  /**< Gray */
    CC_LEAD  = 1,  /**< LEAD (M)JPEG */
    CC_UNINT = 2   /**< Uninterpolated color image (CFA field indicates color ordering)  */
};

/** Color Filter Array */
enum {
    CFA_NONE      = 0,  /**< GRAY */
    CFA_VRI       = 1,  /**< GBRG/RGGB */
    CFA_VRIV6     = 2,  /**< BGGR/GRBG */
    CFA_BAYER     = 3,  /**< GB/RG */
    CFA_BAYERFLIP = 4,  /**< RG/GB */

    CFA_TLGRAY    = 0x80000000,
    CFA_TRGRAY    = 0x40000000,
    CFA_BLGRAY    = 0x20000000,
    CFA_BRGRAY    = 0x10000000
};

static int cine_read_probe(AVProbeData *p)
{
    int HeaderSize;
    if (p->buf[0] == 'C' && p->buf[1] == 'I' &&  // Type
        (HeaderSize = AV_RL16(p->buf + 2)) >= 0x2C &&  // HeaderSize
        AV_RL16(p->buf + 4) <= CC_UNINT &&       // Compression
        AV_RL16(p->buf + 6) <= 1 &&              // Version
        AV_RL32(p->buf + 20) &&                  // ImageCount
        AV_RL32(p->buf + 24) >= HeaderSize &&    // OffImageHeader
        AV_RL32(p->buf + 28) >= HeaderSize &&    // OffSetup
        AV_RL32(p->buf + 32) >= HeaderSize)      // OffImageOffsets
        return AVPROBE_SCORE_MAX;
    return 0;
}

static int set_metadata_int(AVDictionary **dict, const char *key, int value, int allow_zero)
{
    if (value || allow_zero) {
        return av_dict_set_int(dict, key, value, 0);
    }
    return 0;
}

static int set_metadata_float(AVDictionary **dict, const char *key, float value, int allow_zero)
{
    if (value != 0 || allow_zero) {
        char tmp[64];
        snprintf(tmp, sizeof(tmp), "%f", value);
        return av_dict_set(dict, key, tmp, 0);
    }
    return 0;
}

static int cine_read_header(AVFormatContext *avctx)
{
    AVIOContext *pb = avctx->pb;
    AVStream *st;
    unsigned int version, compression, offImageHeader, offSetup, offImageOffsets, biBitCount, length, CFA;
    int vflip;
    char *description;
    uint64_t i;

    st = avformat_new_stream(avctx, NULL);
    if (!st)
        return AVERROR(ENOMEM);
    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
    st->codec->codec_id   = AV_CODEC_ID_RAWVIDEO;
    st->codec->codec_tag  = 0;

    /* CINEFILEHEADER structure */
    avio_skip(pb, 4); // Type, Headersize

    compression = avio_rl16(pb);
    version     = avio_rl16(pb);
    if (version != 1) {
        avpriv_request_sample(avctx, "uknown version %i", version);
        return AVERROR_INVALIDDATA;
    }

    avio_skip(pb, 12); // FirstMovieImage, TotalImageCount, FirstImageNumber

    st->duration    = avio_rl32(pb);
    offImageHeader  = avio_rl32(pb);
    offSetup        = avio_rl32(pb);
    offImageOffsets = avio_rl32(pb);

    avio_skip(pb, 8); // TriggerTime

    /* BITMAPINFOHEADER structure */
    avio_seek(pb, offImageHeader, SEEK_SET);
    avio_skip(pb, 4); //biSize
    st->codec->width      = avio_rl32(pb);
    st->codec->height     = avio_rl32(pb);

    if (avio_rl16(pb) != 1) // biPlanes
        return AVERROR_INVALIDDATA;

    biBitCount = avio_rl16(pb);
    if (biBitCount != 8 && biBitCount != 16 && biBitCount != 24 && biBitCount != 48) {
        avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount);
        return AVERROR_INVALIDDATA;
    }

    switch (avio_rl32(pb)) {
    case BMP_RGB:
        vflip = 0;
        break;
    case 0x100: /* BI_PACKED */
        st->codec->codec_tag = MKTAG('B', 'I', 'T', 0);
        vflip = 1;
        break;
    default:
        avpriv_request_sample(avctx, "unknown bitmap compression");
        return AVERROR_INVALIDDATA;
    }

    avio_skip(pb, 4); // biSizeImage

    /* parse SETUP structure */
    avio_seek(pb, offSetup, SEEK_SET);
    avio_skip(pb, 140); // FrameRatae16 .. descriptionOld
    if (avio_rl16(pb) != 0x5453)
        return AVERROR_INVALIDDATA;
    length = avio_rl16(pb);
    if (length < 0x163C) {
        avpriv_request_sample(avctx, "short SETUP header");
        return AVERROR_INVALIDDATA;
    }

    avio_skip(pb, 616); // Binning .. bFlipH
    if (!avio_rl32(pb) ^ vflip) {
        st->codec->extradata  = av_strdup("BottomUp");
        st->codec->extradata_size  = 9;
    }

    avio_skip(pb, 4); // Grid

    avpriv_set_pts_info(st, 64, 1, avio_rl32(pb));

    avio_skip(pb, 20); // Shutter .. bEnableColor

    set_metadata_int(&st->metadata, "camera_version", avio_rl32(pb), 0);
    set_metadata_int(&st->metadata, "firmware_version", avio_rl32(pb), 0);
    set_metadata_int(&st->metadata, "software_version", avio_rl32(pb), 0);
    set_metadata_int(&st->metadata, "recording_timezone", avio_rl32(pb), 0);

    CFA = avio_rl32(pb);

    set_metadata_int(&st->metadata, "brightness", avio_rl32(pb), 1);
    set_metadata_int(&st->metadata, "contrast", avio_rl32(pb), 1);
    set_metadata_int(&st->metadata, "gamma", avio_rl32(pb), 1);

    avio_skip(pb, 12 + 16); // Reserved1 .. AutoExpRect
    set_metadata_float(&st->metadata, "wbgain[0].r", av_int2float(avio_rl32(pb)), 1);
    set_metadata_float(&st->metadata, "wbgain[0].b", av_int2float(avio_rl32(pb)), 1);
    avio_skip(pb, 36); // WBGain[1].. WBView

    st->codec->bits_per_coded_sample = avio_rl32(pb);

    if (compression == CC_RGB) {
        if (biBitCount == 8) {
            st->codec->pix_fmt = AV_PIX_FMT_GRAY8;
        } else if (biBitCount == 16) {
            st->codec->pix_fmt = AV_PIX_FMT_GRAY16LE;
        } else if (biBitCount == 24) {
            st->codec->pix_fmt = AV_PIX_FMT_BGR24;
        } else if (biBitCount == 48) {
            st->codec->pix_fmt = AV_PIX_FMT_BGR48LE;
        } else {
            avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount);
            return AVERROR_INVALIDDATA;
        }
    } else if (compression == CC_UNINT) {
        switch (CFA & 0xFFFFFF) {
        case CFA_BAYER:
            if (biBitCount == 8) {
                st->codec->pix_fmt = AV_PIX_FMT_BAYER_GBRG8;
            } else if (biBitCount == 16) {
                st->codec->pix_fmt = AV_PIX_FMT_BAYER_GBRG16LE;
            } else {
                avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount);
                return AVERROR_INVALIDDATA;
            }
            break;
        case CFA_BAYERFLIP:
            if (biBitCount == 8) {
                st->codec->pix_fmt = AV_PIX_FMT_BAYER_RGGB8;
            } else if (biBitCount == 16) {
                st->codec->pix_fmt = AV_PIX_FMT_BAYER_RGGB16LE;
            } else {
                avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount);
                return AVERROR_INVALIDDATA;
            }
            break;
        default:
           avpriv_request_sample(avctx, "unsupported Color Field Array (CFA) %i", CFA & 0xFFFFFF);
            return AVERROR_INVALIDDATA;
        }
    } else { //CC_LEAD
        avpriv_request_sample(avctx, "unsupported compression %i", compression);
        return AVERROR_INVALIDDATA;
    }

    avio_skip(pb, 668); // Conv8Min ... Sensor

    set_metadata_int(&st->metadata, "shutter_ns", avio_rl32(pb), 0);

    avio_skip(pb, 24); // EDRShutterNs ... ImHeightAcq

#define DESCRIPTION_SIZE 4096
    description = av_malloc(DESCRIPTION_SIZE + 1);
    if (!description)
        return AVERROR(ENOMEM);
    i = avio_get_str(pb, DESCRIPTION_SIZE, description, DESCRIPTION_SIZE + 1);
    if (i < DESCRIPTION_SIZE)
        avio_skip(pb, DESCRIPTION_SIZE - i);
    if (description[0])
        av_dict_set(&st->metadata, "description", description, AV_DICT_DONT_STRDUP_VAL);
    else
        av_free(description);

    avio_skip(pb, 1176); // RisingEdge ... cmUser

    set_metadata_int(&st->metadata, "enable_crop", avio_rl32(pb), 1);
    set_metadata_int(&st->metadata, "crop_left", avio_rl32(pb), 1);
    set_metadata_int(&st->metadata, "crop_top", avio_rl32(pb), 1);
    set_metadata_int(&st->metadata, "crop_right", avio_rl32(pb), 1);
    set_metadata_int(&st->metadata, "crop_bottom", avio_rl32(pb), 1);

    /* parse image offsets */
    avio_seek(pb, offImageOffsets, SEEK_SET);
    for (i = 0; i < st->duration; i++)
        av_add_index_entry(st, avio_rl64(pb), i, 0, 0, AVINDEX_KEYFRAME);

    return 0;
}

static int cine_read_packet(AVFormatContext *avctx, AVPacket *pkt)
{
    CineDemuxContext *cine = avctx->priv_data;
    AVStream *st = avctx->streams[0];
    AVIOContext *pb = avctx->pb;
    int n, size, ret;

    if (cine->pts >= st->duration)
        return AVERROR_EOF;

    avio_seek(pb, st->index_entries[cine->pts].pos, SEEK_SET);
    n = avio_rl32(pb);
    if (n < 8)
        return AVERROR_INVALIDDATA;
    avio_skip(pb, n - 8);
    size = avio_rl32(pb);

    ret = av_get_packet(pb, pkt, size);
    if (ret < 0)
        return ret;

    pkt->pts = cine->pts++;
    pkt->stream_index = 0;
    pkt->flags |= AV_PKT_FLAG_KEY;
    return 0;
}

static int cine_read_seek(AVFormatContext *avctx, int stream_index, int64_t timestamp, int flags)
{
    CineDemuxContext *cine = avctx->priv_data;

    if ((flags & AVSEEK_FLAG_FRAME) || (flags & AVSEEK_FLAG_BYTE))
        return AVERROR(ENOSYS);

    if (!avctx->pb->seekable)
        return AVERROR(EIO);

    cine->pts = timestamp;
    return 0;
}

AVInputFormat ff_cine_demuxer = {
    .name           = "cine",
    .long_name      = NULL_IF_CONFIG_SMALL("Phantom Cine"),
    .priv_data_size = sizeof(CineDemuxContext),
    .read_probe     = cine_read_probe,
    .read_header    = cine_read_header,
    .read_packet    = cine_read_packet,
    .read_seek      = cine_read_seek,
};
Commit	Line	Data
2ba45a60	1	/*
f6fa7814	2	* Phantom Cine demuxer
2ba45a60 DM	3	* Copyright (c) 2010-2011 Peter Ross <pross@xvid.org>
	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	* Phantom Cine demuxer
	25	* @author Peter Ross <pross@xvid.org>
	26	*/
	27
	28	#include "libavutil/intreadwrite.h"
	29	#include "libavcodec/bmp.h"
f6fa7814	30	#include "libavutil/intfloat.h"
2ba45a60 DM	31	#include "avformat.h"
	32	#include "internal.h"
	33
	34	typedef struct {
	35	uint64_t pts;
	36	} CineDemuxContext;
	37
	38	/** Compression */
	39	enum {
	40	CC_RGB = 0, /*< Gray /
	41	CC_LEAD = 1, /*< LEAD (M)JPEG /
	42	CC_UNINT = 2 /*< Uninterpolated color image (CFA field indicates color ordering) /
	43	};
	44
	45	/** Color Filter Array */
	46	enum {
	47	CFA_NONE = 0, /*< GRAY /
	48	CFA_VRI = 1, /*< GBRG/RGGB /
	49	CFA_VRIV6 = 2, /*< BGGR/GRBG /
	50	CFA_BAYER = 3, /*< GB/RG /
	51	CFA_BAYERFLIP = 4, /*< RG/GB /
	52
	53	CFA_TLGRAY = 0x80000000,
	54	CFA_TRGRAY = 0x40000000,
	55	CFA_BLGRAY = 0x20000000,
	56	CFA_BRGRAY = 0x10000000
	57	};
	58
	59	static int cine_read_probe(AVProbeData *p)
	60	{
	61	int HeaderSize;
	62	if (p->buf[0] == 'C' && p->buf[1] == 'I' && // Type
	63	(HeaderSize = AV_RL16(p->buf + 2)) >= 0x2C && // HeaderSize
	64	AV_RL16(p->buf + 4) <= CC_UNINT && // Compression
	65	AV_RL16(p->buf + 6) <= 1 && // Version
	66	AV_RL32(p->buf + 20) && // ImageCount
	67	AV_RL32(p->buf + 24) >= HeaderSize && // OffImageHeader
	68	AV_RL32(p->buf + 28) >= HeaderSize && // OffSetup
	69	AV_RL32(p->buf + 32) >= HeaderSize) // OffImageOffsets
	70	return AVPROBE_SCORE_MAX;
	71	return 0;
	72	}
	73
	74	static int set_metadata_int(AVDictionary *dict, const char key, int value, int allow_zero)
	75	{
	76	if (value \|\| allow_zero) {
	77	return av_dict_set_int(dict, key, value, 0);
	78	}
	79	return 0;
	80	}
	81
f6fa7814 DM	82	static int set_metadata_float(AVDictionary *dict, const char key, float value, int allow_zero)
	83	{
	84	if (value != 0 \|\| allow_zero) {
	85	char tmp[64];
	86	snprintf(tmp, sizeof(tmp), "%f", value);
	87	return av_dict_set(dict, key, tmp, 0);
	88	}
	89	return 0;
	90	}
	91
2ba45a60 DM	92	static int cine_read_header(AVFormatContext *avctx)
	93	{
	94	AVIOContext *pb = avctx->pb;
	95	AVStream *st;
	96	unsigned int version, compression, offImageHeader, offSetup, offImageOffsets, biBitCount, length, CFA;
	97	int vflip;
	98	char *description;
	99	uint64_t i;
	100
	101	st = avformat_new_stream(avctx, NULL);
	102	if (!st)
	103	return AVERROR(ENOMEM);
	104	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
	105	st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
	106	st->codec->codec_tag = 0;
	107
	108	/* CINEFILEHEADER structure */
	109	avio_skip(pb, 4); // Type, Headersize
	110
	111	compression = avio_rl16(pb);
	112	version = avio_rl16(pb);
	113	if (version != 1) {
	114	avpriv_request_sample(avctx, "uknown version %i", version);
	115	return AVERROR_INVALIDDATA;
	116	}
	117
	118	avio_skip(pb, 12); // FirstMovieImage, TotalImageCount, FirstImageNumber
	119
	120	st->duration = avio_rl32(pb);
	121	offImageHeader = avio_rl32(pb);
	122	offSetup = avio_rl32(pb);
	123	offImageOffsets = avio_rl32(pb);
	124
	125	avio_skip(pb, 8); // TriggerTime
	126
	127	/* BITMAPINFOHEADER structure */
	128	avio_seek(pb, offImageHeader, SEEK_SET);
	129	avio_skip(pb, 4); //biSize
	130	st->codec->width = avio_rl32(pb);
	131	st->codec->height = avio_rl32(pb);
	132
	133	if (avio_rl16(pb) != 1) // biPlanes
	134	return AVERROR_INVALIDDATA;
	135
	136	biBitCount = avio_rl16(pb);
	137	if (biBitCount != 8 && biBitCount != 16 && biBitCount != 24 && biBitCount != 48) {
	138	avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount);
	139	return AVERROR_INVALIDDATA;
	140	}
	141
	142	switch (avio_rl32(pb)) {
	143	case BMP_RGB:
	144	vflip = 0;
	145	break;
	146	case 0x100: /* BI_PACKED */
	147	st->codec->codec_tag = MKTAG('B', 'I', 'T', 0);
	148	vflip = 1;
	149	break;
	150	default:
	151	avpriv_request_sample(avctx, "unknown bitmap compression");
	152	return AVERROR_INVALIDDATA;
	153	}
	154
	155	avio_skip(pb, 4); // biSizeImage
156
157	/* parse SETUP structure */
158	avio_seek(pb, offSetup, SEEK_SET);
159	avio_skip(pb, 140); // FrameRatae16 .. descriptionOld
160	if (avio_rl16(pb) != 0x5453)
161	return AVERROR_INVALIDDATA;
162	length = avio_rl16(pb);
163	if (length < 0x163C) {
164	avpriv_request_sample(avctx, "short SETUP header");
165	return AVERROR_INVALIDDATA;
166	}
167
168	avio_skip(pb, 616); // Binning .. bFlipH
169	if (!avio_rl32(pb) ^ vflip) {
170	st->codec->extradata = av_strdup("BottomUp");
171	st->codec->extradata_size = 9;
172	}
173
174	avio_skip(pb, 4); // Grid
175
176	avpriv_set_pts_info(st, 64, 1, avio_rl32(pb));
177
178	avio_skip(pb, 20); // Shutter .. bEnableColor
179
180	set_metadata_int(&st->metadata, "camera_version", avio_rl32(pb), 0);
181	set_metadata_int(&st->metadata, "firmware_version", avio_rl32(pb), 0);
182	set_metadata_int(&st->metadata, "software_version", avio_rl32(pb), 0);
183	set_metadata_int(&st->metadata, "recording_timezone", avio_rl32(pb), 0);
184
185	CFA = avio_rl32(pb);
186
187	set_metadata_int(&st->metadata, "brightness", avio_rl32(pb), 1);
188	set_metadata_int(&st->metadata, "contrast", avio_rl32(pb), 1);
189	set_metadata_int(&st->metadata, "gamma", avio_rl32(pb), 1);
190
f6fa7814 DM	191	avio_skip(pb, 12 + 16); // Reserved1 .. AutoExpRect
	192	set_metadata_float(&st->metadata, "wbgain[0].r", av_int2float(avio_rl32(pb)), 1);
	193	set_metadata_float(&st->metadata, "wbgain[0].b", av_int2float(avio_rl32(pb)), 1);
	194	avio_skip(pb, 36); // WBGain[1].. WBView
2ba45a60 DM	195
	196	st->codec->bits_per_coded_sample = avio_rl32(pb);
	197
	198	if (compression == CC_RGB) {
	199	if (biBitCount == 8) {
	200	st->codec->pix_fmt = AV_PIX_FMT_GRAY8;
	201	} else if (biBitCount == 16) {
	202	st->codec->pix_fmt = AV_PIX_FMT_GRAY16LE;
	203	} else if (biBitCount == 24) {
	204	st->codec->pix_fmt = AV_PIX_FMT_BGR24;
	205	} else if (biBitCount == 48) {
	206	st->codec->pix_fmt = AV_PIX_FMT_BGR48LE;
	207	} else {
	208	avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount);
	209	return AVERROR_INVALIDDATA;
	210	}
	211	} else if (compression == CC_UNINT) {
	212	switch (CFA & 0xFFFFFF) {
	213	case CFA_BAYER:
	214	if (biBitCount == 8) {
	215	st->codec->pix_fmt = AV_PIX_FMT_BAYER_GBRG8;
	216	} else if (biBitCount == 16) {
	217	st->codec->pix_fmt = AV_PIX_FMT_BAYER_GBRG16LE;
	218	} else {
	219	avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount);
	220	return AVERROR_INVALIDDATA;
	221	}
	222	break;
	223	case CFA_BAYERFLIP:
	224	if (biBitCount == 8) {
	225	st->codec->pix_fmt = AV_PIX_FMT_BAYER_RGGB8;
	226	} else if (biBitCount == 16) {
	227	st->codec->pix_fmt = AV_PIX_FMT_BAYER_RGGB16LE;
	228	} else {
	229	avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount);
	230	return AVERROR_INVALIDDATA;
	231	}
	232	break;
	233	default:
	234	avpriv_request_sample(avctx, "unsupported Color Field Array (CFA) %i", CFA & 0xFFFFFF);
	235	return AVERROR_INVALIDDATA;
	236	}
	237	} else { //CC_LEAD
	238	avpriv_request_sample(avctx, "unsupported compression %i", compression);
	239	return AVERROR_INVALIDDATA;
	240	}
	241
	242	avio_skip(pb, 668); // Conv8Min ... Sensor
	243
	244	set_metadata_int(&st->metadata, "shutter_ns", avio_rl32(pb), 0);
	245
	246	avio_skip(pb, 24); // EDRShutterNs ... ImHeightAcq
	247
	248	#define DESCRIPTION_SIZE 4096
	249	description = av_malloc(DESCRIPTION_SIZE + 1);
	250	if (!description)
	251	return AVERROR(ENOMEM);
	252	i = avio_get_str(pb, DESCRIPTION_SIZE, description, DESCRIPTION_SIZE + 1);
	253	if (i < DESCRIPTION_SIZE)
	254	avio_skip(pb, DESCRIPTION_SIZE - i);
	255	if (description[0])
	256	av_dict_set(&st->metadata, "description", description, AV_DICT_DONT_STRDUP_VAL);
	257	else
	258	av_free(description);
259
260	avio_skip(pb, 1176); // RisingEdge ... cmUser
261
262	set_metadata_int(&st->metadata, "enable_crop", avio_rl32(pb), 1);
263	set_metadata_int(&st->metadata, "crop_left", avio_rl32(pb), 1);
264	set_metadata_int(&st->metadata, "crop_top", avio_rl32(pb), 1);
265	set_metadata_int(&st->metadata, "crop_right", avio_rl32(pb), 1);
266	set_metadata_int(&st->metadata, "crop_bottom", avio_rl32(pb), 1);
267
268	/* parse image offsets */
269	avio_seek(pb, offImageOffsets, SEEK_SET);
270	for (i = 0; i < st->duration; i++)
271	av_add_index_entry(st, avio_rl64(pb), i, 0, 0, AVINDEX_KEYFRAME);
272
273	return 0;
274	}
275
276	static int cine_read_packet(AVFormatContext avctx, AVPacket pkt)
277	{
278	CineDemuxContext *cine = avctx->priv_data;
279	AVStream *st = avctx->streams[0];
280	AVIOContext *pb = avctx->pb;
281	int n, size, ret;
282
283	if (cine->pts >= st->duration)
284	return AVERROR_EOF;
285
286	avio_seek(pb, st->index_entries[cine->pts].pos, SEEK_SET);
287	n = avio_rl32(pb);
288	if (n < 8)
289	return AVERROR_INVALIDDATA;
290	avio_skip(pb, n - 8);
291	size = avio_rl32(pb);
292
293	ret = av_get_packet(pb, pkt, size);
294	if (ret < 0)
295	return ret;
296
297	pkt->pts = cine->pts++;
298	pkt->stream_index = 0;
299	pkt->flags \|= AV_PKT_FLAG_KEY;
300	return 0;
301	}
302
303	static int cine_read_seek(AVFormatContext *avctx, int stream_index, int64_t timestamp, int flags)
304	{
305	CineDemuxContext *cine = avctx->priv_data;
306
307	if ((flags & AVSEEK_FLAG_FRAME) \|\| (flags & AVSEEK_FLAG_BYTE))
308	return AVERROR(ENOSYS);
309
310	if (!avctx->pb->seekable)
311	return AVERROR(EIO);
312
313	cine->pts = timestamp;
314	return 0;
315	}
316
317	AVInputFormat ff_cine_demuxer = {
318	.name = "cine",
319	.long_name = NULL_IF_CONFIG_SMALL("Phantom Cine"),
320	.priv_data_size = sizeof(CineDemuxContext),
321	.read_probe = cine_read_probe,
322	.read_header = cine_read_header,
323	.read_packet = cine_read_packet,
324	.read_seek = cine_read_seek,
325	};