27
27
#include "avcodec.h"
29
28
#include "get_bits.h"
31
/* Disable the encoder. */
32
#undef CONFIG_CLJR_ENCODER
33
#define CONFIG_CLJR_ENCODER 0
35
typedef struct CLJRContext{
36
AVCodecContext *avctx;
31
typedef struct CLJRContext {
35
static av_cold int common_init(AVCodecContext *avctx)
37
CLJRContext * const a = avctx->priv_data;
39
avctx->coded_frame = &a->picture;
44
#if CONFIG_CLJR_DECODER
43
45
static int decode_frame(AVCodecContext *avctx,
44
46
void *data, int *data_size,
47
49
const uint8_t *buf = avpkt->data;
48
int buf_size = avpkt->size;
50
int buf_size = avpkt->size;
49
51
CLJRContext * const a = avctx->priv_data;
50
53
AVFrame *picture = data;
51
AVFrame * const p= (AVFrame*)&a->picture;
54
AVFrame * const p = &a->picture;
55
58
avctx->release_buffer(avctx, p);
57
if(buf_size/avctx->height < avctx->width) {
58
av_log(avctx, AV_LOG_ERROR, "Resolution larger than buffer size. Invalid header?\n");
63
if(avctx->get_buffer(avctx, p) < 0){
60
if (avctx->height <= 0 || avctx->width <= 0) {
61
av_log(avctx, AV_LOG_ERROR, "Invalid width or height\n");
62
return AVERROR_INVALIDDATA;
65
if (buf_size < avctx->height * avctx->width) {
66
av_log(avctx, AV_LOG_ERROR,
67
"Resolution larger than buffer size. Invalid header?\n");
68
return AVERROR_INVALIDDATA;
72
if (avctx->get_buffer(avctx, p) < 0) {
64
73
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
67
p->pict_type= AV_PICTURE_TYPE_I;
70
init_get_bits(&a->gb, buf, buf_size);
72
for(y=0; y<avctx->height; y++){
73
uint8_t *luma= &a->picture.data[0][ y*a->picture.linesize[0] ];
74
uint8_t *cb= &a->picture.data[1][ y*a->picture.linesize[1] ];
75
uint8_t *cr= &a->picture.data[2][ y*a->picture.linesize[2] ];
76
for(x=0; x<avctx->width; x+=4){
77
luma[3] = get_bits(&a->gb, 5) << 3;
78
luma[2] = get_bits(&a->gb, 5) << 3;
79
luma[1] = get_bits(&a->gb, 5) << 3;
80
luma[0] = get_bits(&a->gb, 5) << 3;
82
*(cb++) = get_bits(&a->gb, 6) << 2;
83
*(cr++) = get_bits(&a->gb, 6) << 2;
76
p->pict_type = AV_PICTURE_TYPE_I;
79
init_get_bits(&gb, buf, buf_size * 8);
81
for (y = 0; y < avctx->height; y++) {
82
uint8_t *luma = &a->picture.data[0][y * a->picture.linesize[0]];
83
uint8_t *cb = &a->picture.data[1][y * a->picture.linesize[1]];
84
uint8_t *cr = &a->picture.data[2][y * a->picture.linesize[2]];
85
for (x = 0; x < avctx->width; x += 4) {
86
luma[3] = get_bits(&gb, 5) << 3;
87
luma[2] = get_bits(&gb, 5) << 3;
88
luma[1] = get_bits(&gb, 5) << 3;
89
luma[0] = get_bits(&gb, 5) << 3;
91
*(cb++) = get_bits(&gb, 6) << 2;
92
*(cr++) = get_bits(&gb, 6) << 2;
87
*picture= *(AVFrame*)&a->picture;
96
*picture = a->picture;
88
97
*data_size = sizeof(AVPicture);
95
#if CONFIG_CLJR_ENCODER
96
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
97
CLJRContext * const a = avctx->priv_data;
99
AVFrame * const p= (AVFrame*)&a->picture;
103
p->pict_type= AV_PICTURE_TYPE_I;
108
align_put_bits(&a->pb);
109
while(get_bit_count(&a->pb)&31)
110
put_bits(&a->pb, 8, 0);
112
size= get_bit_count(&a->pb)/32;
118
static av_cold void common_init(AVCodecContext *avctx){
119
CLJRContext * const a = avctx->priv_data;
121
avctx->coded_frame= (AVFrame*)&a->picture;
125
static av_cold int decode_init(AVCodecContext *avctx){
129
avctx->pix_fmt= PIX_FMT_YUV411P;
134
#if CONFIG_CLJR_ENCODER
135
static av_cold int encode_init(AVCodecContext *avctx){
102
static av_cold int decode_init(AVCodecContext *avctx)
104
avctx->pix_fmt = PIX_FMT_YUV411P;
105
return common_init(avctx);
108
static av_cold int decode_end(AVCodecContext *avctx)
110
CLJRContext *a = avctx->priv_data;
112
if (a->picture.data[0])
113
avctx->release_buffer(avctx, &a->picture);
143
117
AVCodec ff_cljr_decoder = {
153
.long_name = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"),
119
.type = AVMEDIA_TYPE_VIDEO,
121
.priv_data_size = sizeof(CLJRContext),
124
.decode = decode_frame,
125
.capabilities = CODEC_CAP_DR1,
126
.long_name = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"),
156
130
#if CONFIG_CLJR_ENCODER
131
static int encode_frame(AVCodecContext *avctx, unsigned char *buf,
132
int buf_size, void *data)
138
p->pict_type = AV_PICTURE_TYPE_I;
141
init_put_bits(&pb, buf, buf_size / 8);
143
for (y = 0; y < avctx->height; y++) {
144
uint8_t *luma = &p->data[0][y * p->linesize[0]];
145
uint8_t *cb = &p->data[1][y * p->linesize[1]];
146
uint8_t *cr = &p->data[2][y * p->linesize[2]];
147
for (x = 0; x < avctx->width; x += 4) {
148
put_bits(&pb, 5, luma[3] >> 3);
149
put_bits(&pb, 5, luma[2] >> 3);
150
put_bits(&pb, 5, luma[1] >> 3);
151
put_bits(&pb, 5, luma[0] >> 3);
153
put_bits(&pb, 6, *(cb++) >> 2);
154
put_bits(&pb, 6, *(cr++) >> 2);
160
return put_bits_count(&pb) / 8;
157
163
AVCodec ff_cljr_encoder = {
165
.long_name = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"),
165
.type = AVMEDIA_TYPE_VIDEO,
167
.priv_data_size = sizeof(CLJRContext),
169
.encode = encode_frame,
170
.pix_fmts = (const enum PixelFormat[]) { PIX_FMT_YUV411P,
172
.long_name = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"),