mirror of
https://github.com/pineappleEA/pineapple-src.git
synced 2024-12-07 22:08:25 -05:00
224 lines
6.7 KiB
C
Executable File
224 lines
6.7 KiB
C
Executable File
/*
|
|
* SMV JPEG decoder
|
|
* Copyright (c) 2013 Ash Hughes
|
|
*
|
|
* 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
|
|
* SMV JPEG decoder.
|
|
*/
|
|
|
|
// #define DEBUG
|
|
#include "avcodec.h"
|
|
#include "libavutil/opt.h"
|
|
#include "libavutil/imgutils.h"
|
|
#include "mjpegdec.h"
|
|
#include "internal.h"
|
|
|
|
typedef struct SMVJpegDecodeContext {
|
|
MJpegDecodeContext jpg;
|
|
AVFrame *picture[2]; /* pictures array */
|
|
AVCodecContext* avctx;
|
|
int frames_per_jpeg;
|
|
int mjpeg_data_size;
|
|
} SMVJpegDecodeContext;
|
|
|
|
static inline void smv_img_pnt_plane(uint8_t **dst, uint8_t *src,
|
|
int src_linesize, int height, int nlines)
|
|
{
|
|
if (!dst || !src)
|
|
return;
|
|
src += (nlines) * src_linesize * height;
|
|
*dst = src;
|
|
}
|
|
|
|
static inline void smv_img_pnt(uint8_t *dst_data[4], uint8_t *src_data[4],
|
|
const int src_linesizes[4],
|
|
enum AVPixelFormat pix_fmt, int width, int height,
|
|
int nlines)
|
|
{
|
|
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
|
|
int i, planes_nb = 0;
|
|
|
|
if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
|
|
return;
|
|
|
|
for (i = 0; i < desc->nb_components; i++)
|
|
planes_nb = FFMAX(planes_nb, desc->comp[i].plane + 1);
|
|
|
|
for (i = 0; i < planes_nb; i++) {
|
|
int h = height;
|
|
if (i == 1 || i == 2) {
|
|
h = AV_CEIL_RSHIFT(height, desc->log2_chroma_h);
|
|
}
|
|
smv_img_pnt_plane(&dst_data[i], src_data[i],
|
|
src_linesizes[i], h, nlines);
|
|
}
|
|
if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
|
|
desc->flags & FF_PSEUDOPAL)
|
|
dst_data[1] = src_data[1];
|
|
}
|
|
|
|
static av_cold int smvjpeg_decode_end(AVCodecContext *avctx)
|
|
{
|
|
SMVJpegDecodeContext *s = avctx->priv_data;
|
|
MJpegDecodeContext *jpg = &s->jpg;
|
|
|
|
jpg->picture_ptr = NULL;
|
|
av_frame_free(&s->picture[0]);
|
|
av_frame_free(&s->picture[1]);
|
|
avcodec_free_context(&s->avctx);
|
|
return 0;
|
|
}
|
|
|
|
static av_cold int smvjpeg_decode_init(AVCodecContext *avctx)
|
|
{
|
|
SMVJpegDecodeContext *s = avctx->priv_data;
|
|
AVCodec *codec;
|
|
AVDictionary *thread_opt = NULL;
|
|
int ret = 0, r;
|
|
|
|
s->frames_per_jpeg = 0;
|
|
|
|
s->picture[0] = av_frame_alloc();
|
|
if (!s->picture[0])
|
|
return AVERROR(ENOMEM);
|
|
|
|
s->picture[1] = av_frame_alloc();
|
|
if (!s->picture[1]) {
|
|
av_frame_free(&s->picture[0]);
|
|
return AVERROR(ENOMEM);
|
|
}
|
|
|
|
s->jpg.picture_ptr = s->picture[0];
|
|
|
|
if (avctx->extradata_size >= 4)
|
|
s->frames_per_jpeg = AV_RL32(avctx->extradata);
|
|
|
|
if (s->frames_per_jpeg <= 0) {
|
|
av_log(avctx, AV_LOG_ERROR, "Invalid number of frames per jpeg.\n");
|
|
ret = AVERROR_INVALIDDATA;
|
|
}
|
|
|
|
codec = avcodec_find_decoder(AV_CODEC_ID_MJPEG);
|
|
if (!codec) {
|
|
av_log(avctx, AV_LOG_ERROR, "MJPEG codec not found\n");
|
|
smvjpeg_decode_end(avctx);
|
|
return AVERROR_DECODER_NOT_FOUND;
|
|
}
|
|
|
|
s->avctx = avcodec_alloc_context3(codec);
|
|
|
|
av_dict_set(&thread_opt, "threads", "1", 0);
|
|
s->avctx->refcounted_frames = 1;
|
|
s->avctx->flags = avctx->flags;
|
|
s->avctx->idct_algo = avctx->idct_algo;
|
|
if ((r = ff_codec_open2_recursive(s->avctx, codec, &thread_opt)) < 0) {
|
|
av_log(avctx, AV_LOG_ERROR, "MJPEG codec failed to open\n");
|
|
ret = r;
|
|
}
|
|
av_dict_free(&thread_opt);
|
|
|
|
if (ret < 0)
|
|
smvjpeg_decode_end(avctx);
|
|
return ret;
|
|
}
|
|
|
|
static int smvjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
|
|
AVPacket *avpkt)
|
|
{
|
|
const AVPixFmtDescriptor *desc;
|
|
SMVJpegDecodeContext *s = avctx->priv_data;
|
|
AVFrame* mjpeg_data = s->picture[0];
|
|
int i, cur_frame = 0, ret = 0;
|
|
|
|
cur_frame = avpkt->pts % s->frames_per_jpeg;
|
|
|
|
/* cur_frame is later used to calculate the buffer offset, so it mustn't be negative */
|
|
if (cur_frame < 0)
|
|
cur_frame += s->frames_per_jpeg;
|
|
|
|
/* Are we at the start of a block? */
|
|
if (!cur_frame) {
|
|
av_frame_unref(mjpeg_data);
|
|
ret = avcodec_decode_video2(s->avctx, mjpeg_data, &s->mjpeg_data_size, avpkt);
|
|
if (ret < 0) {
|
|
s->mjpeg_data_size = 0;
|
|
return ret;
|
|
}
|
|
} else if (!s->mjpeg_data_size)
|
|
return AVERROR(EINVAL);
|
|
|
|
desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
|
|
av_assert0(desc);
|
|
|
|
if (mjpeg_data->height % (s->frames_per_jpeg << desc->log2_chroma_h)) {
|
|
av_log(avctx, AV_LOG_ERROR, "Invalid height\n");
|
|
return AVERROR_INVALIDDATA;
|
|
}
|
|
|
|
/*use the last lot... */
|
|
*data_size = s->mjpeg_data_size;
|
|
|
|
avctx->pix_fmt = s->avctx->pix_fmt;
|
|
|
|
/* We shouldn't get here if frames_per_jpeg <= 0 because this was rejected
|
|
in init */
|
|
ret = ff_set_dimensions(avctx, mjpeg_data->width, mjpeg_data->height / s->frames_per_jpeg);
|
|
if (ret < 0) {
|
|
av_log(s, AV_LOG_ERROR, "Failed to set dimensions\n");
|
|
return ret;
|
|
}
|
|
|
|
if (*data_size) {
|
|
s->picture[1]->extended_data = NULL;
|
|
s->picture[1]->width = avctx->width;
|
|
s->picture[1]->height = avctx->height;
|
|
s->picture[1]->format = avctx->pix_fmt;
|
|
smv_img_pnt(s->picture[1]->data, mjpeg_data->data, mjpeg_data->linesize,
|
|
avctx->pix_fmt, avctx->width, avctx->height, cur_frame);
|
|
for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
|
|
s->picture[1]->linesize[i] = mjpeg_data->linesize[i];
|
|
|
|
ret = av_frame_ref(data, s->picture[1]);
|
|
if (ret < 0)
|
|
return ret;
|
|
}
|
|
|
|
return avpkt->size;
|
|
}
|
|
|
|
static const AVClass smvjpegdec_class = {
|
|
.class_name = "SMVJPEG decoder",
|
|
.item_name = av_default_item_name,
|
|
.version = LIBAVUTIL_VERSION_INT,
|
|
};
|
|
|
|
AVCodec ff_smvjpeg_decoder = {
|
|
.name = "smvjpeg",
|
|
.long_name = NULL_IF_CONFIG_SMALL("SMV JPEG"),
|
|
.type = AVMEDIA_TYPE_VIDEO,
|
|
.id = AV_CODEC_ID_SMVJPEG,
|
|
.priv_data_size = sizeof(SMVJpegDecodeContext),
|
|
.init = smvjpeg_decode_init,
|
|
.close = smvjpeg_decode_end,
|
|
.decode = smvjpeg_decode_frame,
|
|
.priv_class = &smvjpegdec_class,
|
|
};
|