FFmpeg
Main Page
Related Pages
Modules
Namespaces
Data Structures
Files
Examples
File List
Globals
All
Data Structures
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Macros
Groups
Pages
libavcodec
indeo5.c
Go to the documentation of this file.
1
/*
2
* Indeo Video Interactive v5 compatible decoder
3
* Copyright (c) 2009 Maxim Poliakovski
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
* Indeo Video Interactive version 5 decoder
25
*
26
* Indeo5 data is usually transported within .avi or .mov files.
27
* Known FOURCCs: 'IV50'
28
*/
29
30
#define BITSTREAM_READER_LE
31
#include "
avcodec.h
"
32
#include "
get_bits.h
"
33
#include "
ivi_dsp.h
"
34
#include "
ivi_common.h
"
35
#include "
indeo5data.h
"
36
37
/**
38
* Indeo5 frame types.
39
*/
40
enum
{
41
FRAMETYPE_INTRA
= 0,
42
FRAMETYPE_INTER
= 1,
///< non-droppable P-frame
43
FRAMETYPE_INTER_SCAL
= 2,
///< droppable P-frame used in the scalability mode
44
FRAMETYPE_INTER_NOREF
= 3,
///< droppable P-frame
45
FRAMETYPE_NULL
= 4
///< empty frame with no data
46
};
47
48
#define IVI5_PIC_SIZE_ESC 15
49
50
/**
51
* Decode Indeo5 GOP (Group of pictures) header.
52
* This header is present in key frames only.
53
* It defines parameters for all frames in a GOP.
54
*
55
* @param[in,out] ctx ptr to the decoder context
56
* @param[in] avctx ptr to the AVCodecContext
57
* @return result code: 0 = OK, -1 = error
58
*/
59
static
int
decode_gop_header
(
IVI45DecContext
*ctx,
AVCodecContext
*avctx)
60
{
61
int
result, i, p, tile_size, pic_size_indx, mb_size, blk_size, is_scalable;
62
int
quant_mat, blk_size_changed = 0;
63
IVIBandDesc
*
band
, *band1, *band2;
64
IVIPicConfig
pic_conf;
65
66
ctx->
gop_flags
=
get_bits
(&ctx->
gb
, 8);
67
68
ctx->
gop_hdr_size
= (ctx->
gop_flags
& 1) ?
get_bits
(&ctx->
gb
, 16) : 0;
69
70
if
(ctx->
gop_flags
&
IVI5_IS_PROTECTED
)
71
ctx->
lock_word
=
get_bits_long
(&ctx->
gb
, 32);
72
73
tile_size = (ctx->
gop_flags
& 0x40) ? 64 <<
get_bits
(&ctx->
gb
, 2) : 0;
74
if
(tile_size > 256) {
75
av_log
(avctx,
AV_LOG_ERROR
,
"Invalid tile size: %d\n"
, tile_size);
76
return
AVERROR_INVALIDDATA
;
77
}
78
79
/* decode number of wavelet bands */
80
/* num_levels * 3 + 1 */
81
pic_conf.
luma_bands
=
get_bits
(&ctx->
gb
, 2) * 3 + 1;
82
pic_conf.
chroma_bands
=
get_bits1
(&ctx->
gb
) * 3 + 1;
83
is_scalable = pic_conf.
luma_bands
!= 1 || pic_conf.
chroma_bands
!= 1;
84
if
(is_scalable && (pic_conf.
luma_bands
!= 4 || pic_conf.
chroma_bands
!= 1)) {
85
av_log
(avctx,
AV_LOG_ERROR
,
"Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d\n"
,
86
pic_conf.
luma_bands
, pic_conf.
chroma_bands
);
87
return
AVERROR_INVALIDDATA
;
88
}
89
90
pic_size_indx =
get_bits
(&ctx->
gb
, 4);
91
if
(pic_size_indx ==
IVI5_PIC_SIZE_ESC
) {
92
pic_conf.
pic_height
=
get_bits
(&ctx->
gb
, 13);
93
pic_conf.
pic_width
=
get_bits
(&ctx->
gb
, 13);
94
}
else
{
95
pic_conf.
pic_height
=
ivi5_common_pic_sizes
[pic_size_indx * 2 + 1] << 2;
96
pic_conf.
pic_width
=
ivi5_common_pic_sizes
[pic_size_indx * 2 ] << 2;
97
}
98
99
if
(ctx->
gop_flags
& 2) {
100
avpriv_report_missing_feature
(avctx,
"YV12 picture format"
);
101
return
AVERROR_PATCHWELCOME
;
102
}
103
104
pic_conf.
chroma_height
= (pic_conf.
pic_height
+ 3) >> 2;
105
pic_conf.
chroma_width
= (pic_conf.
pic_width
+ 3) >> 2;
106
107
if
(!tile_size) {
108
pic_conf.
tile_height
= pic_conf.
pic_height
;
109
pic_conf.
tile_width
= pic_conf.
pic_width
;
110
}
else
{
111
pic_conf.
tile_height
= pic_conf.
tile_width
= tile_size;
112
}
113
114
/* check if picture layout was changed and reallocate buffers */
115
if
(
ivi_pic_config_cmp
(&pic_conf, &ctx->
pic_conf
) || ctx->
gop_invalid
) {
116
result =
ff_ivi_init_planes
(ctx->
planes
, &pic_conf, 0);
117
if
(result < 0) {
118
av_log
(avctx,
AV_LOG_ERROR
,
"Couldn't reallocate color planes!\n"
);
119
return
result;
120
}
121
ctx->
pic_conf
= pic_conf;
122
ctx->
is_scalable
= is_scalable;
123
blk_size_changed = 1;
/* force reallocation of the internal structures */
124
}
125
126
for
(p = 0; p <= 1; p++) {
127
for
(i = 0; i < (!p ? pic_conf.
luma_bands
: pic_conf.
chroma_bands
); i++) {
128
band = &ctx->
planes
[p].
bands
[i];
129
130
band->
is_halfpel
=
get_bits1
(&ctx->
gb
);
131
132
mb_size =
get_bits1
(&ctx->
gb
);
133
blk_size = 8 >>
get_bits1
(&ctx->
gb
);
134
mb_size = blk_size << !mb_size;
135
136
if
(p==0 && blk_size==4) {
137
av_log
(avctx,
AV_LOG_ERROR
,
"4x4 luma blocks are unsupported!\n"
);
138
return
AVERROR_PATCHWELCOME
;
139
}
140
141
blk_size_changed = mb_size != band->
mb_size
|| blk_size != band->
blk_size
;
142
if
(blk_size_changed) {
143
band->
mb_size
= mb_size;
144
band->
blk_size
= blk_size;
145
}
146
147
if
(
get_bits1
(&ctx->
gb
)) {
148
avpriv_report_missing_feature
(avctx,
"Extended transform info"
);
149
return
AVERROR_PATCHWELCOME
;
150
}
151
152
/* select transform function and scan pattern according to plane and band number */
153
switch
((p << 2) + i) {
154
case
0:
155
band->
inv_transform
=
ff_ivi_inverse_slant_8x8
;
156
band->
dc_transform
=
ff_ivi_dc_slant_2d
;
157
band->
scan
=
ff_zigzag_direct
;
158
band->
transform_size
= 8;
159
break
;
160
161
case
1:
162
band->
inv_transform
=
ff_ivi_row_slant8
;
163
band->
dc_transform
=
ff_ivi_dc_row_slant
;
164
band->
scan
=
ff_ivi_vertical_scan_8x8
;
165
band->
transform_size
= 8;
166
break
;
167
168
case
2:
169
band->
inv_transform
=
ff_ivi_col_slant8
;
170
band->
dc_transform
=
ff_ivi_dc_col_slant
;
171
band->
scan
=
ff_ivi_horizontal_scan_8x8
;
172
band->
transform_size
= 8;
173
break
;
174
175
case
3:
176
band->
inv_transform
=
ff_ivi_put_pixels_8x8
;
177
band->
dc_transform
=
ff_ivi_put_dc_pixel_8x8
;
178
band->
scan
=
ff_ivi_horizontal_scan_8x8
;
179
band->
transform_size
= 8;
180
break
;
181
182
case
4:
183
band->
inv_transform
=
ff_ivi_inverse_slant_4x4
;
184
band->
dc_transform
=
ff_ivi_dc_slant_2d
;
185
band->
scan
=
ff_ivi_direct_scan_4x4
;
186
band->
transform_size
= 4;
187
break
;
188
}
189
190
band->
is_2d_trans
= band->
inv_transform
==
ff_ivi_inverse_slant_8x8
||
191
band->
inv_transform
==
ff_ivi_inverse_slant_4x4
;
192
193
if
(band->
transform_size
!= band->
blk_size
) {
194
av_log
(avctx,
AV_LOG_ERROR
,
"transform and block size mismatch (%d != %d)\n"
, band->
transform_size
, band->
blk_size
);
195
return
AVERROR_INVALIDDATA
;
196
}
197
198
/* select dequant matrix according to plane and band number */
199
if
(!p) {
200
quant_mat = (pic_conf.
luma_bands
> 1) ? i+1 : 0;
201
}
else
{
202
quant_mat = 5;
203
}
204
205
if
(band->
blk_size
== 8) {
206
if
(quant_mat >= 5){
207
av_log
(avctx,
AV_LOG_ERROR
,
"quant_mat %d too large!\n"
, quant_mat);
208
return
-1;
209
}
210
band->
intra_base
= &
ivi5_base_quant_8x8_intra
[quant_mat][0];
211
band->
inter_base
= &
ivi5_base_quant_8x8_inter
[quant_mat][0];
212
band->
intra_scale
= &
ivi5_scale_quant_8x8_intra
[quant_mat][0];
213
band->
inter_scale
= &
ivi5_scale_quant_8x8_inter
[quant_mat][0];
214
}
else
{
215
band->
intra_base
=
ivi5_base_quant_4x4_intra
;
216
band->
inter_base
=
ivi5_base_quant_4x4_inter
;
217
band->
intra_scale
=
ivi5_scale_quant_4x4_intra
;
218
band->
inter_scale
=
ivi5_scale_quant_4x4_inter
;
219
}
220
221
if
(
get_bits
(&ctx->
gb
, 2)) {
222
av_log
(avctx,
AV_LOG_ERROR
,
"End marker missing!\n"
);
223
return
AVERROR_INVALIDDATA
;
224
}
225
}
226
}
227
228
/* copy chroma parameters into the 2nd chroma plane */
229
for
(i = 0; i < pic_conf.
chroma_bands
; i++) {
230
band1 = &ctx->
planes
[1].
bands
[i];
231
band2 = &ctx->
planes
[2].
bands
[i];
232
233
band2->
width
= band1->
width
;
234
band2->
height
= band1->
height
;
235
band2->
mb_size
= band1->
mb_size
;
236
band2->
blk_size
= band1->
blk_size
;
237
band2->
is_halfpel
= band1->
is_halfpel
;
238
band2->
intra_base
= band1->
intra_base
;
239
band2->
inter_base
= band1->
inter_base
;
240
band2->
intra_scale
= band1->
intra_scale
;
241
band2->
inter_scale
= band1->
inter_scale
;
242
band2->
scan
= band1->
scan
;
243
band2->
inv_transform
= band1->
inv_transform
;
244
band2->
dc_transform
= band1->
dc_transform
;
245
band2->
is_2d_trans
= band1->
is_2d_trans
;
246
band2->
transform_size
= band1->
transform_size
;
247
}
248
249
/* reallocate internal structures if needed */
250
if
(blk_size_changed) {
251
result =
ff_ivi_init_tiles
(ctx->
planes
, pic_conf.
tile_width
,
252
pic_conf.
tile_height
);
253
if
(result < 0) {
254
av_log
(avctx,
AV_LOG_ERROR
,
255
"Couldn't reallocate internal structures!\n"
);
256
return
result;
257
}
258
}
259
260
if
(ctx->
gop_flags
& 8) {
261
if
(
get_bits
(&ctx->
gb
, 3)) {
262
av_log
(avctx,
AV_LOG_ERROR
,
"Alignment bits are not zero!\n"
);
263
return
AVERROR_INVALIDDATA
;
264
}
265
266
if
(
get_bits1
(&ctx->
gb
))
267
skip_bits_long
(&ctx->
gb
, 24);
/* skip transparency fill color */
268
}
269
270
align_get_bits
(&ctx->
gb
);
271
272
skip_bits
(&ctx->
gb
, 23);
/* FIXME: unknown meaning */
273
274
/* skip GOP extension if any */
275
if
(
get_bits1
(&ctx->
gb
)) {
276
do
{
277
i =
get_bits
(&ctx->
gb
, 16);
278
}
while
(i & 0x8000);
279
}
280
281
align_get_bits
(&ctx->
gb
);
282
283
return
0;
284
}
285
286
287
/**
288
* Skip a header extension.
289
*
290
* @param[in,out] gb the GetBit context
291
*/
292
static
inline
int
skip_hdr_extension
(
GetBitContext
*gb)
293
{
294
int
i,
len
;
295
296
do
{
297
len =
get_bits
(gb, 8);
298
if
(8*len >
get_bits_left
(gb))
299
return
AVERROR_INVALIDDATA
;
300
for
(i = 0; i <
len
; i++)
skip_bits
(gb, 8);
301
}
while
(len);
302
303
return
0;
304
}
305
306
307
/**
308
* Decode Indeo5 picture header.
309
*
310
* @param[in,out] ctx ptr to the decoder context
311
* @param[in] avctx ptr to the AVCodecContext
312
* @return result code: 0 = OK, -1 = error
313
*/
314
static
int
decode_pic_hdr
(
IVI45DecContext
*ctx,
AVCodecContext
*avctx)
315
{
316
int
ret
;
317
318
if
(
get_bits
(&ctx->
gb
, 5) != 0x1F) {
319
av_log
(avctx,
AV_LOG_ERROR
,
"Invalid picture start code!\n"
);
320
return
AVERROR_INVALIDDATA
;
321
}
322
323
ctx->
prev_frame_type
= ctx->
frame_type
;
324
ctx->
frame_type
=
get_bits
(&ctx->
gb
, 3);
325
if
(ctx->
frame_type
>= 5) {
326
av_log
(avctx,
AV_LOG_ERROR
,
"Invalid frame type: %d \n"
, ctx->
frame_type
);
327
return
AVERROR_INVALIDDATA
;
328
}
329
330
ctx->
frame_num
=
get_bits
(&ctx->
gb
, 8);
331
332
if
(ctx->
frame_type
==
FRAMETYPE_INTRA
) {
333
if
((ret =
decode_gop_header
(ctx, avctx)) < 0) {
334
av_log
(avctx,
AV_LOG_ERROR
,
"Invalid GOP header, skipping frames.\n"
);
335
ctx->
gop_invalid
= 1;
336
return
ret
;
337
}
338
ctx->
gop_invalid
= 0;
339
}
340
341
if
(ctx->
frame_type
==
FRAMETYPE_INTER_SCAL
&& !ctx->
is_scalable
) {
342
av_log
(avctx,
AV_LOG_ERROR
,
"Scalable inter frame in non scalable stream\n"
);
343
ctx->
frame_type
=
FRAMETYPE_INTER
;
344
return
AVERROR_INVALIDDATA
;
345
}
346
347
if
(ctx->
frame_type
!=
FRAMETYPE_NULL
) {
348
ctx->
frame_flags
=
get_bits
(&ctx->
gb
, 8);
349
350
ctx->
pic_hdr_size
= (ctx->
frame_flags
& 1) ?
get_bits_long
(&ctx->
gb
, 24) : 0;
351
352
ctx->
checksum
= (ctx->
frame_flags
& 0x10) ?
get_bits
(&ctx->
gb
, 16) : 0;
353
354
/* skip unknown extension if any */
355
if
(ctx->
frame_flags
& 0x20)
356
skip_hdr_extension
(&ctx->
gb
);
/* XXX: untested */
357
358
/* decode macroblock huffman codebook */
359
ret =
ff_ivi_dec_huff_desc
(&ctx->
gb
, ctx->
frame_flags
& 0x40,
360
IVI_MB_HUFF
, &ctx->
mb_vlc
, avctx);
361
if
(ret < 0)
362
return
ret
;
363
364
skip_bits
(&ctx->
gb
, 3);
/* FIXME: unknown meaning! */
365
}
366
367
align_get_bits
(&ctx->
gb
);
368
369
return
0;
370
}
371
372
373
/**
374
* Decode Indeo5 band header.
375
*
376
* @param[in,out] ctx ptr to the decoder context
377
* @param[in,out] band ptr to the band descriptor
378
* @param[in] avctx ptr to the AVCodecContext
379
* @return result code: 0 = OK, -1 = error
380
*/
381
static
int
decode_band_hdr
(
IVI45DecContext
*ctx,
IVIBandDesc
*
band
,
382
AVCodecContext
*avctx)
383
{
384
int
i,
ret
;
385
uint8_t
band_flags;
386
387
band_flags =
get_bits
(&ctx->
gb
, 8);
388
389
if
(band_flags & 1) {
390
band->
is_empty
= 1;
391
return
0;
392
}
393
394
band->
data_size
= (ctx->
frame_flags
& 0x80) ?
get_bits_long
(&ctx->
gb
, 24) : 0;
395
396
band->
inherit_mv
= band_flags & 2;
397
band->
inherit_qdelta
= band_flags & 8;
398
band->
qdelta_present
= band_flags & 4;
399
if
(!band->
qdelta_present
) band->
inherit_qdelta
= 1;
400
401
/* decode rvmap probability corrections if any */
402
band->
num_corr
= 0;
/* there are no corrections */
403
if
(band_flags & 0x10) {
404
band->
num_corr
=
get_bits
(&ctx->
gb
, 8);
/* get number of correction pairs */
405
if
(band->
num_corr
> 61) {
406
av_log
(avctx,
AV_LOG_ERROR
,
"Too many corrections: %d\n"
,
407
band->
num_corr
);
408
return
AVERROR_INVALIDDATA
;
409
}
410
411
/* read correction pairs */
412
for
(i = 0; i < band->
num_corr
* 2; i++)
413
band->
corr
[i] =
get_bits
(&ctx->
gb
, 8);
414
}
415
416
/* select appropriate rvmap table for this band */
417
band->
rvmap_sel
= (band_flags & 0x40) ?
get_bits
(&ctx->
gb
, 3) : 8;
418
419
/* decode block huffman codebook */
420
ret =
ff_ivi_dec_huff_desc
(&ctx->
gb
, band_flags & 0x80,
IVI_BLK_HUFF
,
421
&band->
blk_vlc
, avctx);
422
if
(ret < 0)
423
return
ret
;
424
425
band->
checksum_present
=
get_bits1
(&ctx->
gb
);
426
if
(band->
checksum_present
)
427
band->
checksum
=
get_bits
(&ctx->
gb
, 16);
428
429
band->
glob_quant
=
get_bits
(&ctx->
gb
, 5);
430
431
/* skip unknown extension if any */
432
if
(band_flags & 0x20) {
/* XXX: untested */
433
align_get_bits
(&ctx->
gb
);
434
skip_hdr_extension
(&ctx->
gb
);
435
}
436
437
align_get_bits
(&ctx->
gb
);
438
439
return
0;
440
}
441
442
443
/**
444
* Decode info (block type, cbp, quant delta, motion vector)
445
* for all macroblocks in the current tile.
446
*
447
* @param[in,out] ctx ptr to the decoder context
448
* @param[in,out] band ptr to the band descriptor
449
* @param[in,out] tile ptr to the tile descriptor
450
* @param[in] avctx ptr to the AVCodecContext
451
* @return result code: 0 = OK, -1 = error
452
*/
453
static
int
decode_mb_info
(
IVI45DecContext
*ctx,
IVIBandDesc
*
band
,
454
IVITile
*tile,
AVCodecContext
*avctx)
455
{
456
int
x,
y
, mv_x, mv_y, mv_delta, offs, mb_offset,
457
mv_scale
, blks_per_mb,
s
;
458
IVIMbInfo
*
mb
, *ref_mb;
459
int
row_offset = band->
mb_size
* band->
pitch
;
460
461
mb = tile->
mbs
;
462
ref_mb = tile->
ref_mbs
;
463
offs = tile->
ypos
* band->
pitch
+ tile->
xpos
;
464
465
if
(!ref_mb &&
466
((band->
qdelta_present
&& band->
inherit_qdelta
) || band->
inherit_mv
))
467
return
AVERROR_INVALIDDATA
;
468
469
if
(tile->
num_MBs
!=
IVI_MBs_PER_TILE
(tile->
width
, tile->
height
, band->
mb_size
)) {
470
av_log
(avctx,
AV_LOG_ERROR
,
"Allocated tile size %d mismatches parameters %d\n"
,
471
tile->
num_MBs
,
IVI_MBs_PER_TILE
(tile->
width
, tile->
height
, band->
mb_size
));
472
return
AVERROR_INVALIDDATA
;
473
}
474
475
/* scale factor for motion vectors */
476
mv_scale = (ctx->
planes
[0].
bands
[0].
mb_size
>> 3) - (band->
mb_size
>> 3);
477
mv_x = mv_y = 0;
478
479
for
(y = tile->
ypos
; y < (tile->
ypos
+ tile->
height
); y += band->
mb_size
) {
480
mb_offset = offs;
481
482
for
(x = tile->
xpos
; x < (tile->
xpos
+ tile->
width
); x += band->
mb_size
) {
483
mb->
xpos
= x;
484
mb->
ypos
=
y
;
485
mb->
buf_offs
= mb_offset;
486
487
if
(
get_bits1
(&ctx->
gb
)) {
488
if
(ctx->
frame_type
==
FRAMETYPE_INTRA
) {
489
av_log
(avctx,
AV_LOG_ERROR
,
"Empty macroblock in an INTRA picture!\n"
);
490
return
AVERROR_INVALIDDATA
;
491
}
492
mb->
type
= 1;
/* empty macroblocks are always INTER */
493
mb->
cbp
= 0;
/* all blocks are empty */
494
495
mb->
q_delta
= 0;
496
if
(!band->
plane
&& !band->
band_num
&& (ctx->
frame_flags
& 8)) {
497
mb->
q_delta
=
get_vlc2
(&ctx->
gb
, ctx->
mb_vlc
.
tab
->
table
,
498
IVI_VLC_BITS
, 1);
499
mb->
q_delta
=
IVI_TOSIGNED
(mb->
q_delta
);
500
}
501
502
mb->
mv_x
= mb->
mv_y
= 0;
/* no motion vector coded */
503
if
(band->
inherit_mv
&& ref_mb){
504
/* motion vector inheritance */
505
if
(mv_scale) {
506
mb->
mv_x
=
ivi_scale_mv
(ref_mb->
mv_x
, mv_scale);
507
mb->
mv_y
=
ivi_scale_mv
(ref_mb->
mv_y
, mv_scale);
508
}
else
{
509
mb->
mv_x
= ref_mb->
mv_x
;
510
mb->
mv_y
= ref_mb->
mv_y
;
511
}
512
}
513
}
else
{
514
if
(band->
inherit_mv
&& ref_mb) {
515
mb->
type
= ref_mb->
type
;
/* copy mb_type from corresponding reference mb */
516
}
else
if
(ctx->
frame_type
==
FRAMETYPE_INTRA
) {
517
mb->
type
= 0;
/* mb_type is always INTRA for intra-frames */
518
}
else
{
519
mb->
type
=
get_bits1
(&ctx->
gb
);
520
}
521
522
blks_per_mb = band->
mb_size
!= band->
blk_size
? 4 : 1;
523
mb->
cbp
=
get_bits
(&ctx->
gb
, blks_per_mb);
524
525
mb->
q_delta
= 0;
526
if
(band->
qdelta_present
) {
527
if
(band->
inherit_qdelta
) {
528
if
(ref_mb) mb->
q_delta
= ref_mb->
q_delta
;
529
}
else
if
(mb->
cbp
|| (!band->
plane
&& !band->
band_num
&&
530
(ctx->
frame_flags
& 8))) {
531
mb->
q_delta
=
get_vlc2
(&ctx->
gb
, ctx->
mb_vlc
.
tab
->
table
,
532
IVI_VLC_BITS
, 1);
533
mb->
q_delta
=
IVI_TOSIGNED
(mb->
q_delta
);
534
}
535
}
536
537
if
(!mb->
type
) {
538
mb->
mv_x
= mb->
mv_y
= 0;
/* there is no motion vector in intra-macroblocks */
539
}
else
{
540
if
(band->
inherit_mv
&& ref_mb){
541
/* motion vector inheritance */
542
if
(mv_scale) {
543
mb->
mv_x
=
ivi_scale_mv
(ref_mb->
mv_x
, mv_scale);
544
mb->
mv_y
=
ivi_scale_mv
(ref_mb->
mv_y
, mv_scale);
545
}
else
{
546
mb->
mv_x
= ref_mb->
mv_x
;
547
mb->
mv_y
= ref_mb->
mv_y
;
548
}
549
}
else
{
550
/* decode motion vector deltas */
551
mv_delta =
get_vlc2
(&ctx->
gb
, ctx->
mb_vlc
.
tab
->
table
,
552
IVI_VLC_BITS
, 1);
553
mv_y +=
IVI_TOSIGNED
(mv_delta);
554
mv_delta =
get_vlc2
(&ctx->
gb
, ctx->
mb_vlc
.
tab
->
table
,
555
IVI_VLC_BITS
, 1);
556
mv_x +=
IVI_TOSIGNED
(mv_delta);
557
mb->
mv_x
= mv_x;
558
mb->
mv_y
= mv_y;
559
}
560
}
561
}
562
563
s= band->
is_halfpel
;
564
if
(mb->
type
)
565
if
( x + (mb->
mv_x
>>s) + (y+ (mb->
mv_y
>>s))*band->
pitch
< 0 ||
566
x + ((mb->
mv_x
+s)>>s) + band->
mb_size
- 1
567
+ (y+band->
mb_size
- 1 +((mb->
mv_y
+s)>>s))*band->
pitch
> band->
bufsize
- 1) {
568
av_log
(avctx,
AV_LOG_ERROR
,
"motion vector %d %d outside reference\n"
, x*s + mb->
mv_x
, y*s + mb->
mv_y
);
569
return
AVERROR_INVALIDDATA
;
570
}
571
572
mb++;
573
if
(ref_mb)
574
ref_mb++;
575
mb_offset += band->
mb_size
;
576
}
577
578
offs += row_offset;
579
}
580
581
align_get_bits
(&ctx->
gb
);
582
583
return
0;
584
}
585
586
587
/**
588
* Switch buffers.
589
*
590
* @param[in,out] ctx ptr to the decoder context
591
*/
592
static
void
switch_buffers
(
IVI45DecContext
*ctx)
593
{
594
switch
(ctx->
prev_frame_type
) {
595
case
FRAMETYPE_INTRA
:
596
case
FRAMETYPE_INTER
:
597
ctx->
buf_switch
^= 1;
598
ctx->
dst_buf
= ctx->
buf_switch
;
599
ctx->
ref_buf
= ctx->
buf_switch
^ 1;
600
break
;
601
case
FRAMETYPE_INTER_SCAL
:
602
if
(!ctx->
inter_scal
) {
603
ctx->
ref2_buf
= 2;
604
ctx->
inter_scal
= 1;
605
}
606
FFSWAP
(
int
, ctx->
dst_buf
, ctx->
ref2_buf
);
607
ctx->
ref_buf
= ctx->
ref2_buf
;
608
break
;
609
case
FRAMETYPE_INTER_NOREF
:
610
break
;
611
}
612
613
switch
(ctx->
frame_type
) {
614
case
FRAMETYPE_INTRA
:
615
ctx->
buf_switch
= 0;
616
/* FALLTHROUGH */
617
case
FRAMETYPE_INTER
:
618
ctx->
inter_scal
= 0;
619
ctx->
dst_buf
= ctx->
buf_switch
;
620
ctx->
ref_buf
= ctx->
buf_switch
^ 1;
621
break
;
622
case
FRAMETYPE_INTER_SCAL
:
623
case
FRAMETYPE_INTER_NOREF
:
624
case
FRAMETYPE_NULL
:
625
break
;
626
}
627
}
628
629
630
static
int
is_nonnull_frame
(
IVI45DecContext
*ctx)
631
{
632
return
ctx->
frame_type
!=
FRAMETYPE_NULL
;
633
}
634
635
636
/**
637
* Initialize Indeo5 decoder.
638
*/
639
static
av_cold
int
decode_init
(
AVCodecContext
*avctx)
640
{
641
IVI45DecContext
*ctx = avctx->
priv_data
;
642
int
result;
643
644
ff_ivi_init_static_vlc
();
645
646
/* copy rvmap tables in our context so we can apply changes to them */
647
memcpy(ctx->
rvmap_tabs
,
ff_ivi_rvmap_tabs
,
sizeof
(
ff_ivi_rvmap_tabs
));
648
649
/* set the initial picture layout according to the basic profile:
650
there is only one band per plane (no scalability), only one tile (no local decoding)
651
and picture format = YVU9 */
652
ctx->
pic_conf
.
pic_width
= avctx->
width
;
653
ctx->
pic_conf
.
pic_height
= avctx->
height
;
654
ctx->
pic_conf
.
chroma_width
= (avctx->
width
+ 3) >> 2;
655
ctx->
pic_conf
.
chroma_height
= (avctx->
height
+ 3) >> 2;
656
ctx->
pic_conf
.
tile_width
= avctx->
width
;
657
ctx->
pic_conf
.
tile_height
= avctx->
height
;
658
ctx->
pic_conf
.
luma_bands
= ctx->
pic_conf
.
chroma_bands
= 1;
659
660
result =
ff_ivi_init_planes
(ctx->
planes
, &ctx->
pic_conf
, 0);
661
if
(result) {
662
av_log
(avctx,
AV_LOG_ERROR
,
"Couldn't allocate color planes!\n"
);
663
return
AVERROR_INVALIDDATA
;
664
}
665
666
ctx->
buf_switch
= 0;
667
ctx->
inter_scal
= 0;
668
669
ctx->
decode_pic_hdr
=
decode_pic_hdr
;
670
ctx->
decode_band_hdr
=
decode_band_hdr
;
671
ctx->
decode_mb_info
=
decode_mb_info
;
672
ctx->
switch_buffers
=
switch_buffers
;
673
ctx->
is_nonnull_frame
=
is_nonnull_frame
;
674
675
ctx->
is_indeo4
= 0;
676
677
avctx->
pix_fmt
=
AV_PIX_FMT_YUV410P
;
678
679
return
0;
680
}
681
682
AVCodec
ff_indeo5_decoder
= {
683
.
name
=
"indeo5"
,
684
.long_name =
NULL_IF_CONFIG_SMALL
(
"Intel Indeo Video Interactive 5"
),
685
.type =
AVMEDIA_TYPE_VIDEO
,
686
.id =
AV_CODEC_ID_INDEO5
,
687
.priv_data_size =
sizeof
(
IVI45DecContext
),
688
.
init
=
decode_init
,
689
.close =
ff_ivi_decode_close
,
690
.
decode
=
ff_ivi_decode_frame
,
691
.capabilities =
CODEC_CAP_DR1
,
692
};
Generated on Sun Mar 8 2015 02:34:54 for FFmpeg by
1.8.2