* @author Nathan Caldwell
*/
+#include <inttypes.h>
+
#include "avcodec.h"
#include "get_bits.h"
#include "mathops.h"
-#include "dsputil.h"
+#include "huffyuvdsp.h"
#include "lagarithrac.h"
#include "thread.h"
typedef struct LagarithContext {
AVCodecContext *avctx;
- AVFrame picture;
- DSPContext dsp;
+ HuffYUVDSPContext hdsp;
int zeros; /**< number of consecutive zero bytes encountered */
int zeros_rem; /**< number of zero bytes remaining to output */
uint8_t *rgb_planes;
+ int rgb_planes_allocated;
int rgb_stride;
} LagarithContext;
}
/* Comment from reference source:
* if (b & 0x80 == 0) { // order of operations is 'wrong'; it has been left this way
- * // since the compression change is negligable and fixing it
- * // breaks backwards compatibilty
+ * // since the compression change is negligible and fixing it
+ * // breaks backwards compatibility
* b =- (signed int)b;
* b &= 0xFF;
* } else {
uint8_t *diff, int w, int *left,
int *left_top)
{
- /* This is almost identical to add_hfyu_median_prediction in dsputil.h.
+ /* This is almost identical to add_hfyu_median_pred in huffyuvdsp.h.
* However the &0xFF on the gradient predictor yealds incorrect output
* for lagarith.
*/
int L, TL;
if (!line) {
+ int i, align_width = (width - 1) & ~31;
/* Left prediction only for first line */
- L = l->dsp.add_hfyu_left_prediction(buf + 1, buf + 1,
- width - 1, buf[0]);
+ L = l->hdsp.add_hfyu_left_pred(buf + 1, buf + 1, align_width, buf[0]);
+ for (i = align_width + 1; i < width; i++)
+ buf[i] += buf[i - 1];
} else {
/* Left pixel is actually prev_row[width] */
L = buf[width - stride - 1];
int L, TL;
if (!line) {
+ int i, align_width;
if (is_luma) {
buf++;
width--;
}
- l->dsp.add_hfyu_left_prediction(buf + 1, buf + 1, width - 1, buf[0]);
+
+ align_width = (width - 1) & ~31;
+ l->hdsp.add_hfyu_left_pred(buf + 1, buf + 1, align_width, buf[0]);
+
+ for (i = align_width + 1; i < width; i++)
+ buf[i] += buf[i - 1];
+
return;
}
if (line == 1) {
L += buf[i];
buf[i] = L;
}
- buf += HEAD;
- width -= HEAD;
+ for (; i < width; i++) {
+ L = mid_pred(L & 0xFF, buf[i - stride], (L + buf[i - stride] - TL) & 0xFF) + buf[i];
+ TL = buf[i - stride];
+ buf[i] = L;
+ }
} else {
TL = buf[width - (2 * stride) - 1];
L = buf[width - stride - 1];
+ l->hdsp.add_hfyu_median_pred(buf, buf - stride, buf, width, &L, &TL);
}
- l->dsp.add_hfyu_median_prediction(buf, buf - stride, buf, width,
- &L, &TL);
}
static int lag_decode_line(LagarithContext *l, lag_rac *rac,
if (read > length)
av_log(l->avctx, AV_LOG_WARNING,
- "Output more bytes than length (%d of %d)\n", read,
+ "Output more bytes than length (%d of %"PRIu32")\n", read,
length);
} else if (esc_count < 8) {
esc_count -= 4;
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
LagarithContext *l = avctx->priv_data;
- AVFrame *const p = &l->picture;
+ ThreadFrame frame = { .f = data };
+ AVFrame *const p = data;
uint8_t frametype = 0;
uint32_t offset_gu = 0, offset_bv = 0, offset_ry = 9;
uint32_t offs[4];
uint8_t *srcs[4], *dst;
int i, j, planes = 3;
- AVFrame *picture = data;
-
- if (p->data[0])
- ff_thread_release_buffer(avctx, p);
-
- p->reference = 0;
p->key_frame = 1;
frametype = buf[0];
case FRAME_SOLID_RGBA:
avctx->pix_fmt = AV_PIX_FMT_RGB32;
- if (ff_thread_get_buffer(avctx, p) < 0) {
+ if (ff_thread_get_buffer(avctx, &frame, 0) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
if (frametype == FRAME_ARITH_RGB24 || frametype == FRAME_U_RGB24)
avctx->pix_fmt = AV_PIX_FMT_RGB24;
- if (ff_thread_get_buffer(avctx, p) < 0) {
+ if (ff_thread_get_buffer(avctx, &frame, 0) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
offs[1] = offset_gu;
offs[2] = offset_ry;
+ l->rgb_stride = FFALIGN(avctx->width, 16);
+ av_fast_malloc(&l->rgb_planes, &l->rgb_planes_allocated,
+ l->rgb_stride * avctx->height * planes + 1);
if (!l->rgb_planes) {
- l->rgb_stride = FFALIGN(avctx->width, 16);
- l->rgb_planes = av_malloc(l->rgb_stride * avctx->height * planes + 1);
- if (!l->rgb_planes) {
- av_log(avctx, AV_LOG_ERROR, "cannot allocate temporary buffer\n");
- return AVERROR(ENOMEM);
- }
+ av_log(avctx, AV_LOG_ERROR, "cannot allocate temporary buffer\n");
+ return AVERROR(ENOMEM);
}
for (i = 0; i < planes; i++)
srcs[i] = l->rgb_planes + (i + 1) * l->rgb_stride * avctx->height - l->rgb_stride;
case FRAME_ARITH_YUY2:
avctx->pix_fmt = AV_PIX_FMT_YUV422P;
- if (ff_thread_get_buffer(avctx, p) < 0) {
+ if (ff_thread_get_buffer(avctx, &frame, 0) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
case FRAME_ARITH_YV12:
avctx->pix_fmt = AV_PIX_FMT_YUV420P;
- if (ff_thread_get_buffer(avctx, p) < 0) {
+ if (ff_thread_get_buffer(avctx, &frame, 0) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
break;
default:
av_log(avctx, AV_LOG_ERROR,
- "Unsupported Lagarith frame type: %#x\n", frametype);
+ "Unsupported Lagarith frame type: %#"PRIx8"\n", frametype);
return -1;
}
- *picture = *p;
*got_frame = 1;
return buf_size;
LagarithContext *l = avctx->priv_data;
l->avctx = avctx;
- ff_dsputil_init(&l->dsp, avctx);
+ ff_huffyuvdsp_init(&l->hdsp);
return 0;
}
{
LagarithContext *l = avctx->priv_data;
- if (l->picture.data[0])
- ff_thread_release_buffer(avctx, &l->picture);
av_freep(&l->rgb_planes);
return 0;
AVCodec ff_lagarith_decoder = {
.name = "lagarith",
+ .long_name = NULL_IF_CONFIG_SMALL("Lagarith lossless"),
.type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_LAGARITH,
.priv_data_size = sizeof(LagarithContext),
.close = lag_decode_end,
.decode = lag_decode_frame,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
- .long_name = NULL_IF_CONFIG_SMALL("Lagarith lossless"),
};
projects / ffmpeg / blobdiff