FFmpeg  4.4.6
roqvideodec.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2003 The FFmpeg project
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * id RoQ Video Decoder by Dr. Tim Ferguson
24  * For more information about the id RoQ format, visit:
25  * http://www.csse.monash.edu.au/~timf/
26  */
27 
28 #include "libavutil/avassert.h"
29 #include "libavutil/imgutils.h"
30 
31 #include "avcodec.h"
32 #include "bytestream.h"
33 #include "internal.h"
34 #include "roqvideo.h"
35 
37 {
38  unsigned int chunk_id = 0, chunk_arg = 0;
39  unsigned long chunk_size = 0;
40  int i, j, k, nv1, nv2, vqflg = 0, vqflg_pos = -1;
41  int vqid, xpos, ypos, xp, yp, x, y, mx, my;
42  roq_qcell *qcell;
44 
45  while (bytestream2_get_bytes_left(gb) >= 8) {
46  chunk_id = bytestream2_get_le16(gb);
47  chunk_size = bytestream2_get_le32(gb);
48  chunk_arg = bytestream2_get_le16(gb);
49 
50  if(chunk_id == RoQ_QUAD_VQ)
51  break;
52  if(chunk_id == RoQ_QUAD_CODEBOOK) {
53  if((nv1 = chunk_arg >> 8) == 0)
54  nv1 = 256;
55  if((nv2 = chunk_arg & 0xff) == 0 && nv1 * 6 < chunk_size)
56  nv2 = 256;
57  for(i = 0; i < nv1; i++) {
58  ri->cb2x2[i].y[0] = bytestream2_get_byte(gb);
59  ri->cb2x2[i].y[1] = bytestream2_get_byte(gb);
60  ri->cb2x2[i].y[2] = bytestream2_get_byte(gb);
61  ri->cb2x2[i].y[3] = bytestream2_get_byte(gb);
62  ri->cb2x2[i].u = bytestream2_get_byte(gb);
63  ri->cb2x2[i].v = bytestream2_get_byte(gb);
64  }
65  for(i = 0; i < nv2; i++)
66  for(j = 0; j < 4; j++)
67  ri->cb4x4[i].idx[j] = bytestream2_get_byte(gb);
68  }
69  }
70 
72  xpos = ypos = 0;
73 
74  if (chunk_size > bytestream2_get_bytes_left(gb)) {
75  av_log(ri->avctx, AV_LOG_ERROR, "Chunk does not fit in input buffer\n");
76  chunk_size = bytestream2_get_bytes_left(gb);
77  }
78 
79  while (bytestream2_tell(gb) < chunk_start + chunk_size) {
80  for (yp = ypos; yp < ypos + 16; yp += 8)
81  for (xp = xpos; xp < xpos + 16; xp += 8) {
82  if (bytestream2_tell(gb) >= chunk_start + chunk_size) {
83  av_log(ri->avctx, AV_LOG_VERBOSE, "Chunk is too short\n");
84  return;
85  }
86  if (vqflg_pos < 0) {
87  vqflg = bytestream2_get_le16(gb);
88  vqflg_pos = 7;
89  }
90  vqid = (vqflg >> (vqflg_pos * 2)) & 0x3;
91  vqflg_pos--;
92 
93  switch(vqid) {
94  case RoQ_ID_MOT:
95  break;
96  case RoQ_ID_FCC: {
97  int byte = bytestream2_get_byte(gb);
98  mx = 8 - (byte >> 4) - ((signed char) (chunk_arg >> 8));
99  my = 8 - (byte & 0xf) - ((signed char) chunk_arg);
100  ff_apply_motion_8x8(ri, xp, yp, mx, my);
101  break;
102  }
103  case RoQ_ID_SLD:
104  qcell = ri->cb4x4 + bytestream2_get_byte(gb);
105  ff_apply_vector_4x4(ri, xp, yp, ri->cb2x2 + qcell->idx[0]);
106  ff_apply_vector_4x4(ri, xp + 4, yp, ri->cb2x2 + qcell->idx[1]);
107  ff_apply_vector_4x4(ri, xp, yp + 4, ri->cb2x2 + qcell->idx[2]);
108  ff_apply_vector_4x4(ri, xp + 4, yp + 4, ri->cb2x2 + qcell->idx[3]);
109  break;
110  case RoQ_ID_CCC:
111  for (k = 0; k < 4; k++) {
112  x = xp; y = yp;
113  if(k & 0x01) x += 4;
114  if(k & 0x02) y += 4;
115 
116  if (bytestream2_tell(gb) >= chunk_start + chunk_size) {
117  av_log(ri->avctx, AV_LOG_VERBOSE, "Chunk is too short\n");
118  return;
119  }
120  if (vqflg_pos < 0) {
121  vqflg = bytestream2_get_le16(gb);
122  vqflg_pos = 7;
123  }
124  vqid = (vqflg >> (vqflg_pos * 2)) & 0x3;
125  vqflg_pos--;
126  switch(vqid) {
127  case RoQ_ID_MOT:
128  break;
129  case RoQ_ID_FCC: {
130  int byte = bytestream2_get_byte(gb);
131  mx = 8 - (byte >> 4) - ((signed char) (chunk_arg >> 8));
132  my = 8 - (byte & 0xf) - ((signed char) chunk_arg);
133  ff_apply_motion_4x4(ri, x, y, mx, my);
134  break;
135  }
136  case RoQ_ID_SLD:
137  qcell = ri->cb4x4 + bytestream2_get_byte(gb);
138  ff_apply_vector_2x2(ri, x, y, ri->cb2x2 + qcell->idx[0]);
139  ff_apply_vector_2x2(ri, x + 2, y, ri->cb2x2 + qcell->idx[1]);
140  ff_apply_vector_2x2(ri, x, y + 2, ri->cb2x2 + qcell->idx[2]);
141  ff_apply_vector_2x2(ri, x + 2, y + 2, ri->cb2x2 + qcell->idx[3]);
142  break;
143  case RoQ_ID_CCC:
144  ff_apply_vector_2x2(ri, x, y, ri->cb2x2 + bytestream2_get_byte(gb));
145  ff_apply_vector_2x2(ri, x + 2, y, ri->cb2x2 + bytestream2_get_byte(gb));
146  ff_apply_vector_2x2(ri, x, y + 2, ri->cb2x2 + bytestream2_get_byte(gb));
147  ff_apply_vector_2x2(ri, x + 2, y + 2, ri->cb2x2 + bytestream2_get_byte(gb));
148  break;
149  }
150  }
151  break;
152  default:
153  av_assert2(0);
154  }
155  }
156 
157  xpos += 16;
158  if (xpos >= ri->width) {
159  xpos -= ri->width;
160  ypos += 16;
161  }
162  if(ypos >= ri->height)
163  break;
164  }
165 }
166 
167 
169 {
170  RoqContext *s = avctx->priv_data;
171 
172  s->avctx = avctx;
173 
174  if (avctx->width % 16 || avctx->height % 16) {
175  avpriv_request_sample(avctx, "Dimensions not being a multiple of 16");
176  return AVERROR_PATCHWELCOME;
177  }
178 
179  s->width = avctx->width;
180  s->height = avctx->height;
181 
182  s->last_frame = av_frame_alloc();
183  s->current_frame = av_frame_alloc();
184  if (!s->current_frame || !s->last_frame)
185  return AVERROR(ENOMEM);
186 
187  avctx->pix_fmt = AV_PIX_FMT_YUVJ444P;
188  avctx->color_range = AVCOL_RANGE_JPEG;
189 
190  return 0;
191 }
192 
194  void *data, int *got_frame,
195  AVPacket *avpkt)
196 {
197  const uint8_t *buf = avpkt->data;
198  int buf_size = avpkt->size;
199  RoqContext *s = avctx->priv_data;
200  int copy = !s->current_frame->data[0] && s->last_frame->data[0];
201  GetByteContext gb;
202  int ret;
203 
204  if ((ret = ff_reget_buffer(avctx, s->current_frame, 0)) < 0)
205  return ret;
206 
207  if (copy) {
208  ret = av_frame_copy(s->current_frame, s->last_frame);
209  if (ret < 0)
210  return ret;
211  }
212 
213  bytestream2_init(&gb, buf, buf_size);
214  roqvideo_decode_frame(s, &gb);
215 
216  if ((ret = av_frame_ref(data, s->current_frame)) < 0)
217  return ret;
218  *got_frame = 1;
219 
220  /* shuffle frames */
221  FFSWAP(AVFrame *, s->current_frame, s->last_frame);
222 
223  return buf_size;
224 }
225 
227 {
228  RoqContext *s = avctx->priv_data;
229 
230  av_frame_free(&s->current_frame);
231  av_frame_free(&s->last_frame);
232 
233  return 0;
234 }
235 
237  .name = "roqvideo",
238  .long_name = NULL_IF_CONFIG_SMALL("id RoQ video"),
239  .type = AVMEDIA_TYPE_VIDEO,
240  .id = AV_CODEC_ID_ROQ,
241  .priv_data_size = sizeof(RoqContext),
243  .close = roq_decode_end,
245  .capabilities = AV_CODEC_CAP_DR1,
246  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
247 };
#define av_cold
Definition: attributes.h:88
uint8_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
#define s(width, name)
Definition: cbs_vp9.c:257
#define FFSWAP(type, a, b)
Definition: common.h:108
long long int64_t
Definition: coverity.c:34
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Identical in function to ff_get_buffer(), except it reuses the existing buffer if available.
Definition: decode.c:2007
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
@ AV_CODEC_ID_ROQ
Definition: codec_id.h:87
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVERROR(e)
Definition: error.h:43
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:443
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:799
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
misc image utilities
int i
Definition: input.c:407
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
const char data[16]
Definition: mxf.c:142
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:586
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
void ff_apply_vector_4x4(RoqContext *ri, int x, int y, roq_cell *cell)
Definition: roqvideo.c:71
void ff_apply_motion_4x4(RoqContext *ri, int x, int y, int deltax, int deltay)
Definition: roqvideo.c:133
void ff_apply_vector_2x2(RoqContext *ri, int x, int y, roq_cell *cell)
Definition: roqvideo.c:41
void ff_apply_motion_8x8(RoqContext *ri, int x, int y, int deltax, int deltay)
Definition: roqvideo.c:139
#define RoQ_ID_SLD
Definition: roqvideo.h:59
#define RoQ_ID_CCC
Definition: roqvideo.h:60
#define RoQ_ID_FCC
Definition: roqvideo.h:58
#define RoQ_ID_MOT
Definition: roqvideo.h:57
#define RoQ_QUAD_CODEBOOK
Definition: roqvideo.h:52
#define RoQ_QUAD_VQ
Definition: roqvideo.h:53
static av_cold int roq_decode_end(AVCodecContext *avctx)
Definition: roqvideodec.c:226
static void roqvideo_decode_frame(RoqContext *ri, GetByteContext *gb)
Definition: roqvideodec.c:36
AVCodec ff_roq_decoder
Definition: roqvideodec.c:236
static int roq_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: roqvideodec.c:193
static av_cold int roq_decode_init(AVCodecContext *avctx)
Definition: roqvideodec.c:168
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int width
picture width / height.
Definition: avcodec.h:709
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1171
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
uint8_t * data
Definition: packet.h:369
AVCodecContext * avctx
Definition: roqvideo.h:42
roq_cell cb2x2[256]
Definition: roqvideo.h:47
int width
Definition: roqvideo.h:45
int height
Definition: roqvideo.h:45
roq_qcell cb4x4[256]
Definition: roqvideo.h:48
unsigned char u
Definition: roqvideo.h:29
unsigned char y[4]
Definition: roqvideo.h:28
unsigned char v
Definition: roqvideo.h:29
int idx[4]
Definition: roqvideo.h:33
#define avpriv_request_sample(...)
#define av_log(a,...)
static void copy(const float *p1, float *p2, const int length)
static int chunk_start(AVFormatContext *s)
Definition: webm_chunk.c:169