2
* Copyright (c) 2003 The FFmpeg Project.
4
* This library is free software; you can redistribute it and/or
5
* modify it under the terms of the GNU Lesser General Public
6
* License as published by the Free Software Foundation; either
7
* version 2 of the License, or (at your option) any later version.
9
* This library is distributed in the hope that it will be useful,
10
* but WITHOUT ANY WARRANTY; without even the implied warranty of
11
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12
* Lesser General Public License for more details.
14
* You should have received a copy of the GNU Lesser General Public
15
* License along with this library; if not, write to the Free Software
16
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
* How to use this decoder:
20
* SVQ3 data is transported within Apple Quicktime files. Quicktime files
21
* have stsd atoms to describe media trak properties. A stsd atom for a
22
* video trak contains 1 or more ImageDescription atoms. These atoms begin
23
* with the 4-byte length of the atom followed by the codec fourcc. Some
24
* decoders need information in this atom to operate correctly. Such
25
* is the case with SVQ3. In order to get the best use out of this decoder,
26
* the calling app must make the SVQ3 ImageDescription atom available
27
* via the AVCodecContext's extradata[_size] field:
29
* AVCodecContext.extradata = pointer to ImageDescription, first characters
30
* are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
31
* AVCodecContext.extradata_size = size of ImageDescription atom memory
32
* buffer (which will be the same as the ImageDescription atom size field
33
* from the QT file, minus 4 bytes since the length is missing)
35
* You will know you have these parameters passed correctly when the decoder
36
* correctly decodes this file:
37
* ftp://ftp.mplayerhq.hu/MPlayer/samples/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
46
#define FULLPEL_MODE 1
47
#define HALFPEL_MODE 2
48
#define THIRDPEL_MODE 3
49
#define PREDICT_MODE 4
51
/* dual scan (from some older h264 draft)
60
static const uint8_t svq3_scan[16]={
61
0+0*4, 1+0*4, 2+0*4, 2+1*4,
62
2+2*4, 3+0*4, 3+1*4, 3+2*4,
63
0+1*4, 0+2*4, 1+1*4, 1+2*4,
64
0+3*4, 1+3*4, 2+3*4, 3+3*4,
67
static const uint8_t svq3_pred_0[25][2] = {
70
{ 0, 2 }, { 1, 1 }, { 2, 0 },
71
{ 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
72
{ 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
73
{ 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
74
{ 2, 4 }, { 3, 3 }, { 4, 2 },
79
static const int8_t svq3_pred_1[6][6][5] = {
80
{ { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
81
{ 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
82
{ { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
83
{ 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
84
{ { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
85
{ 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
86
{ { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
87
{ 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
88
{ { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
89
{ 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
90
{ { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
91
{ 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
94
static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
95
{ { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
96
{ 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
97
{ { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
98
{ 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
101
static const uint32_t svq3_dequant_coeff[32] = {
102
3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
103
9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
104
24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
105
61694, 68745, 77615, 89113,100253,109366,126635,141533
109
static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp){
110
const int qmul= svq3_dequant_coeff[qp];
114
static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};
115
static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
118
const int offset= y_offset[i];
119
const int z0= 13*(block[offset+stride*0] + block[offset+stride*4]);
120
const int z1= 13*(block[offset+stride*0] - block[offset+stride*4]);
121
const int z2= 7* block[offset+stride*1] - 17*block[offset+stride*5];
122
const int z3= 17* block[offset+stride*1] + 7*block[offset+stride*5];
131
const int offset= x_offset[i];
132
const int z0= 13*(temp[4*0+i] + temp[4*2+i]);
133
const int z1= 13*(temp[4*0+i] - temp[4*2+i]);
134
const int z2= 7* temp[4*1+i] - 17*temp[4*3+i];
135
const int z3= 17* temp[4*1+i] + 7*temp[4*3+i];
137
block[stride*0 +offset]= ((z0 + z3)*qmul + 0x80000)>>20;
138
block[stride*2 +offset]= ((z1 + z2)*qmul + 0x80000)>>20;
139
block[stride*8 +offset]= ((z1 - z2)*qmul + 0x80000)>>20;
140
block[stride*10+offset]= ((z0 - z3)*qmul + 0x80000)>>20;
145
static void svq3_add_idct_c (uint8_t *dst, DCTELEM *block, int stride, int qp, int dc){
146
const int qmul= svq3_dequant_coeff[qp];
148
uint8_t *cm = cropTbl + MAX_NEG_CROP;
151
dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
155
for (i=0; i < 4; i++) {
156
const int z0= 13*(block[0 + 4*i] + block[2 + 4*i]);
157
const int z1= 13*(block[0 + 4*i] - block[2 + 4*i]);
158
const int z2= 7* block[1 + 4*i] - 17*block[3 + 4*i];
159
const int z3= 17* block[1 + 4*i] + 7*block[3 + 4*i];
161
block[0 + 4*i]= z0 + z3;
162
block[1 + 4*i]= z1 + z2;
163
block[2 + 4*i]= z1 - z2;
164
block[3 + 4*i]= z0 - z3;
167
for (i=0; i < 4; i++) {
168
const int z0= 13*(block[i + 4*0] + block[i + 4*2]);
169
const int z1= 13*(block[i + 4*0] - block[i + 4*2]);
170
const int z2= 7* block[i + 4*1] - 17*block[i + 4*3];
171
const int z3= 17* block[i + 4*1] + 7*block[i + 4*3];
172
const int rr= (dc + 0x80000);
174
dst[i + stride*0]= cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
175
dst[i + stride*1]= cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
176
dst[i + stride*2]= cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
177
dst[i + stride*3]= cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
181
static void pred4x4_down_left_svq3_c(uint8_t *src, uint8_t *topright, int stride){
184
const __attribute__((unused)) int unu0= t0;
185
const __attribute__((unused)) int unu1= l0;
187
src[0+0*stride]=(l1 + t1)>>1;
189
src[0+1*stride]=(l2 + t2)>>1;
202
src[3+3*stride]=(l3 + t3)>>1;
205
static void pred16x16_plane_svq3_c(uint8_t *src, int stride){
206
pred16x16_plane_compat_c(src, stride, 1);
209
static inline int svq3_decode_block (GetBitContext *gb, DCTELEM *block,
210
int index, const int type) {
212
static const uint8_t *const scan_patterns[4] =
213
{ luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
215
int run, level, sign, vlc, limit;
216
const int intra = (3 * type) >> 2;
217
const uint8_t *const scan = scan_patterns[type];
219
for (limit=(16 >> intra); index < 16; index=limit, limit+=8) {
220
for (; (vlc = svq3_get_ue_golomb (gb)) != 0; index++) {
222
if (vlc == INVALID_VLC)
225
sign = (vlc & 0x1) - 1;
226
vlc = (vlc + 1) >> 1;
232
} else if (vlc < 4) {
237
level = ((vlc + 9) >> 2) - run;
241
run = svq3_dct_tables[intra][vlc].run;
242
level = svq3_dct_tables[intra][vlc].level;
245
level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
248
level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
252
if ((index += run) >= limit)
255
block[scan[index]] = (level ^ sign) - sign;
266
static inline void svq3_mc_dir_part (MpegEncContext *s,
267
int x, int y, int width, int height,
268
int mx, int my, int dxy,
269
int thirdpel, int dir, int avg) {
271
const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
274
int blocksize= 2 - (width>>3); //16->0, 8->1, 4->2
279
if (mx < 0 || mx >= (s->h_edge_pos - width - 1) ||
280
my < 0 || my >= (s->v_edge_pos - height - 1)) {
282
if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
286
mx = clip (mx, -16, (s->h_edge_pos - width + 15));
287
my = clip (my, -16, (s->v_edge_pos - height + 15));
290
/* form component predictions */
291
dest = s->current_picture.data[0] + x + y*s->linesize;
292
src = pic->data[0] + mx + my*s->linesize;
295
ff_emulated_edge_mc (s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
296
mx, my, s->h_edge_pos, s->v_edge_pos);
297
src = s->edge_emu_buffer;
300
(avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
302
(avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
304
if (!(s->flags & CODEC_FLAG_GRAY)) {
305
mx = (mx + (mx < (int) x)) >> 1;
306
my = (my + (my < (int) y)) >> 1;
307
width = (width >> 1);
308
height = (height >> 1);
311
for (i=1; i < 3; i++) {
312
dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
313
src = pic->data[i] + mx + my*s->uvlinesize;
316
ff_emulated_edge_mc (s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
317
mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
318
src = s->edge_emu_buffer;
321
(avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
323
(avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
328
static inline int svq3_mc_dir (H264Context *h, int size, int mode, int dir, int avg) {
330
int i, j, k, mx, my, dx, dy, x, y;
331
MpegEncContext *const s = (MpegEncContext *) h;
332
const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
333
const int part_height = 16 >> ((unsigned) (size + 1) / 3);
334
const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
335
const int h_edge_pos = 6*(s->h_edge_pos - part_width ) - extra_width;
336
const int v_edge_pos = 6*(s->v_edge_pos - part_height) - extra_width;
338
for (i=0; i < 16; i+=part_height) {
339
for (j=0; j < 16; j+=part_width) {
340
const int b_xy = (4*s->mb_x+(j>>2)) + (4*s->mb_y+(i>>2))*h->b_stride;
344
k = ((j>>2)&1) + ((i>>1)&2) + ((j>>1)&4) + (i&8);
346
if (mode != PREDICT_MODE) {
347
pred_motion (h, k, (part_width >> 2), dir, 1, &mx, &my);
349
mx = s->next_picture.motion_val[0][b_xy][0]<<1;
350
my = s->next_picture.motion_val[0][b_xy][1]<<1;
353
mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
354
my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
356
mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
357
my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
361
/* clip motion vector prediction to frame border */
362
mx = clip (mx, extra_width - 6*x, h_edge_pos - 6*x);
363
my = clip (my, extra_width - 6*y, v_edge_pos - 6*y);
365
/* get (optional) motion vector differential */
366
if (mode == PREDICT_MODE) {
369
dy = svq3_get_se_golomb (&s->gb);
370
dx = svq3_get_se_golomb (&s->gb);
372
if (dx == INVALID_VLC || dy == INVALID_VLC) {
373
av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
378
/* compute motion vector */
379
if (mode == THIRDPEL_MODE) {
381
mx = ((mx + 1)>>1) + dx;
382
my = ((my + 1)>>1) + dy;
383
fx= ((unsigned)(mx + 0x3000))/3 - 0x1000;
384
fy= ((unsigned)(my + 0x3000))/3 - 0x1000;
385
dxy= (mx - 3*fx) + 4*(my - 3*fy);
387
svq3_mc_dir_part (s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
390
} else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
391
mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
392
my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
393
dxy= (mx&1) + 2*(my&1);
395
svq3_mc_dir_part (s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
399
mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
400
my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
402
svq3_mc_dir_part (s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
407
/* update mv_cache */
408
if (mode != PREDICT_MODE) {
409
int32_t mv = pack16to32(mx,my);
411
if (part_height == 8 && i < 8) {
412
*(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
414
if (part_width == 8 && j < 8) {
415
*(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
418
if (part_width == 8 && j < 8) {
419
*(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
421
if (part_width == 4 || part_height == 4) {
422
*(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
426
/* write back motion vectors */
427
fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
434
static int svq3_decode_mb (H264Context *h, unsigned int mb_type) {
435
int i, j, k, m, dir, mode;
439
MpegEncContext *const s = (MpegEncContext *) h;
440
const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
441
const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
443
h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
444
h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
445
h->topright_samples_available = 0xFFFF;
447
if (mb_type == 0) { /* SKIP */
448
if (s->pict_type == P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
449
svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
451
if (s->pict_type == B_TYPE) {
452
svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
455
mb_type = MB_TYPE_SKIP;
457
mb_type= FFMIN(s->next_picture.mb_type[mb_xy], 6);
458
if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 0, 0) < 0)
460
if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 1, 1) < 0)
463
mb_type = MB_TYPE_16x16;
465
} else if (mb_type < 8) { /* INTER */
466
if (h->thirdpel_flag && h->halfpel_flag == !get_bits (&s->gb, 1)) {
467
mode = THIRDPEL_MODE;
468
} else if (h->halfpel_flag && h->thirdpel_flag == !get_bits (&s->gb, 1)) {
475
/* note ref_cache should contain here:
484
for (m=0; m < 2; m++) {
485
if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) {
486
for (i=0; i < 4; i++) {
487
*(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - 1 + i*h->b_stride];
490
for (i=0; i < 4; i++) {
491
*(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
495
memcpy (h->mv_cache[m][scan8[0] - 1*8], s->current_picture.motion_val[m][b_xy - h->b_stride], 4*2*sizeof(int16_t));
496
memset (&h->ref_cache[m][scan8[0] - 1*8], (h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1, 4);
498
if (s->mb_x < (s->mb_width - 1)) {
499
*(uint32_t *) h->mv_cache[m][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride + 4];
500
h->ref_cache[m][scan8[0] + 4 - 1*8] =
501
(h->intra4x4_pred_mode[mb_xy - s->mb_stride + 1][0] == -1 ||
502
h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1;
504
h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
506
*(uint32_t *) h->mv_cache[m][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride - 1];
507
h->ref_cache[m][scan8[0] - 1 - 1*8] = (h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] == -1) ? PART_NOT_AVAILABLE : 1;
509
h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
511
memset (&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
513
if (s->pict_type != B_TYPE)
517
/* decode motion vector(s) and form prediction(s) */
518
if (s->pict_type == P_TYPE) {
519
if(svq3_mc_dir (h, (mb_type - 1), mode, 0, 0) < 0)
521
} else { /* B_TYPE */
523
if(svq3_mc_dir (h, 0, mode, 0, 0) < 0)
526
for (i=0; i < 4; i++) {
527
memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
531
if(svq3_mc_dir (h, 0, mode, 1, (mb_type == 3)) < 0)
534
for (i=0; i < 4; i++) {
535
memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
540
mb_type = MB_TYPE_16x16;
541
} else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
542
memset (h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
546
for (i=0; i < 4; i++) {
547
h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i];
549
if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
550
h->left_samples_available = 0x5F5F;
554
h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4];
555
h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5];
556
h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6];
557
h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3];
559
if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
560
h->top_samples_available = 0x33FF;
564
/* decode prediction codes for luma blocks */
565
for (i=0; i < 16; i+=2) {
566
vlc = svq3_get_ue_golomb (&s->gb);
569
av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
573
left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
574
top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
576
left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
577
left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
579
if (left[1] == -1 || left[2] == -1){
580
av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
584
} else { /* mb_type == 33, DC_128_PRED block type */
585
for (i=0; i < 4; i++) {
586
memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
590
write_back_intra_pred_mode (h);
593
check_intra4x4_pred_mode (h);
595
h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
596
h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
598
for (i=0; i < 4; i++) {
599
memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
602
h->top_samples_available = 0x33FF;
603
h->left_samples_available = 0x5F5F;
606
mb_type = MB_TYPE_INTRA4x4;
607
} else { /* INTRA16x16 */
608
dir = i_mb_type_info[mb_type - 8].pred_mode;
609
dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
611
if ((h->intra16x16_pred_mode = check_intra_pred_mode (h, dir)) == -1){
612
av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
616
cbp = i_mb_type_info[mb_type - 8].cbp;
617
mb_type = MB_TYPE_INTRA16x16;
620
if (!IS_INTER(mb_type) && s->pict_type != I_TYPE) {
621
for (i=0; i < 4; i++) {
622
memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
624
if (s->pict_type == B_TYPE) {
625
for (i=0; i < 4; i++) {
626
memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
630
if (!IS_INTRA4x4(mb_type)) {
631
memset (h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
633
if (!IS_SKIP(mb_type) || s->pict_type == B_TYPE) {
634
memset (h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
635
s->dsp.clear_blocks(h->mb);
638
if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == B_TYPE)) {
639
if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48){
640
av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
644
cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
646
if (IS_INTRA16x16(mb_type) || (s->pict_type != I_TYPE && s->adaptive_quant && cbp)) {
647
s->qscale += svq3_get_se_golomb (&s->gb);
650
av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
654
if (IS_INTRA16x16(mb_type)) {
655
if (svq3_decode_block (&s->gb, h->mb, 0, 0)){
656
av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
662
const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
663
const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
665
for (i=0; i < 4; i++) {
666
if ((cbp & (1 << i))) {
667
for (j=0; j < 4; j++) {
668
k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
669
h->non_zero_count_cache[ scan8[k] ] = 1;
671
if (svq3_decode_block (&s->gb, &h->mb[16*k], index, type)){
672
av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
680
for (i=0; i < 2; ++i) {
681
if (svq3_decode_block (&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
682
av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
688
for (i=0; i < 8; i++) {
689
h->non_zero_count_cache[ scan8[16+i] ] = 1;
691
if (svq3_decode_block (&s->gb, &h->mb[16*(16 + i)], 1, 1)){
692
av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
700
s->current_picture.mb_type[mb_xy] = mb_type;
702
if (IS_INTRA(mb_type)) {
703
h->chroma_pred_mode = check_intra_pred_mode (h, DC_PRED8x8);
709
static int svq3_decode_slice_header (H264Context *h) {
710
MpegEncContext *const s = (MpegEncContext *) h;
711
const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
714
header = get_bits (&s->gb, 8);
716
if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
718
av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
721
int length = (header >> 5) & 3;
723
h->next_slice_index = get_bits_count(&s->gb) + 8*show_bits (&s->gb, 8*length) + 8*length;
725
if (h->next_slice_index > s->gb.size_in_bits){
726
av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
730
s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
731
skip_bits(&s->gb, 8);
734
memcpy ((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
735
&s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
739
if ((i = svq3_get_ue_golomb (&s->gb)) == INVALID_VLC || i >= 3){
740
av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
744
h->slice_type = golomb_to_pict_type[i];
746
if ((header & 0x9F) == 2) {
747
i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
748
s->mb_skip_run = get_bits (&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
754
h->slice_num = get_bits (&s->gb, 8);
755
s->qscale = get_bits (&s->gb, 5);
756
s->adaptive_quant = get_bits1 (&s->gb);
761
if (h->unknown_svq3_flag) {
766
get_bits (&s->gb, 2);
768
while (get_bits1 (&s->gb)) {
769
get_bits (&s->gb, 8);
772
/* reset intra predictors and invalidate motion vector references */
774
memset (h->intra4x4_pred_mode[mb_xy - 1], -1, 4*sizeof(int8_t));
775
memset (h->intra4x4_pred_mode[mb_xy - s->mb_x], -1, 8*sizeof(int8_t)*s->mb_x);
778
memset (h->intra4x4_pred_mode[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
781
h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] = -1;
788
static int svq3_decode_frame (AVCodecContext *avctx,
789
void *data, int *data_size,
790
uint8_t *buf, int buf_size) {
791
MpegEncContext *const s = avctx->priv_data;
792
H264Context *const h = avctx->priv_data;
794
unsigned char *extradata;
797
s->flags = avctx->flags;
798
s->flags2 = avctx->flags2;
799
s->unrestricted_mv = 1;
801
if (!s->context_initialized) {
802
s->width = avctx->width;
803
s->height = avctx->height;
804
h->pred4x4[DIAG_DOWN_LEFT_PRED] = pred4x4_down_left_svq3_c;
805
h->pred16x16[PLANE_PRED8x8] = pred16x16_plane_svq3_c;
807
h->thirdpel_flag = 1;
808
h->unknown_svq3_flag = 0;
811
if (MPV_common_init (s) < 0)
814
h->b_stride = 4*s->mb_width;
818
/* prowl for the "SEQH" marker in the extradata */
819
extradata = (unsigned char *)avctx->extradata;
820
for (m = 0; m < avctx->extradata_size; m++) {
821
if (!memcmp (extradata, "SEQH", 4))
826
/* if a match was found, parse the extra data */
827
if (!memcmp (extradata, "SEQH", 4)) {
831
size = BE_32(&extradata[4]);
832
init_get_bits (&gb, extradata + 8, size*8);
834
/* 'frame size code' and optional 'width, height' */
835
if (get_bits (&gb, 3) == 7) {
840
h->halfpel_flag = get_bits1 (&gb);
841
h->thirdpel_flag = get_bits1 (&gb);
849
s->low_delay = get_bits1 (&gb);
854
while (get_bits1 (&gb)) {
858
h->unknown_svq3_flag = get_bits1 (&gb);
859
avctx->has_b_frames = !s->low_delay;
863
/* special case for last picture */
865
if (s->next_picture_ptr && !s->low_delay) {
866
*(AVFrame *) data = *(AVFrame *) &s->next_picture;
867
*data_size = sizeof(AVFrame);
872
init_get_bits (&s->gb, buf, 8*buf_size);
874
s->mb_x = s->mb_y = 0;
876
if (svq3_decode_slice_header (h))
879
s->pict_type = h->slice_type;
880
s->picture_number = h->slice_num;
882
if(avctx->debug&FF_DEBUG_PICT_INFO){
883
av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d\n",
884
av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
885
s->adaptive_quant, s->qscale
889
/* for hurry_up==5 */
890
s->current_picture.pict_type = s->pict_type;
891
s->current_picture.key_frame = (s->pict_type == I_TYPE);
893
/* skip b frames if we dont have reference frames */
894
if (s->last_picture_ptr == NULL && s->pict_type == B_TYPE) return 0;
895
/* skip b frames if we are in a hurry */
896
if (avctx->hurry_up && s->pict_type == B_TYPE) return 0;
897
/* skip everything if we are in a hurry >= 5 */
898
if (avctx->hurry_up >= 5) return 0;
899
if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
900
||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
901
|| avctx->skip_frame >= AVDISCARD_ALL)
904
if (s->next_p_frame_damaged) {
905
if (s->pict_type == B_TYPE)
908
s->next_p_frame_damaged = 0;
913
if (s->pict_type == B_TYPE) {
914
h->frame_num_offset = (h->slice_num - h->prev_frame_num);
916
if (h->frame_num_offset < 0) {
917
h->frame_num_offset += 256;
919
if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
920
av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
924
h->prev_frame_num = h->frame_num;
925
h->frame_num = h->slice_num;
926
h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
928
if (h->prev_frame_num_offset < 0) {
929
h->prev_frame_num_offset += 256;
938
h->ref_cache[m][scan8[0] + 8*i + j]= 1;
939
h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
943
for (s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) {
944
for (s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
946
if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
947
((get_bits_count(&s->gb) & 7) == 0 || show_bits (&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
949
skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
950
s->gb.size_in_bits = 8*buf_size;
952
if (svq3_decode_slice_header (h))
955
/* TODO: support s->mb_skip_run */
958
mb_type = svq3_get_ue_golomb (&s->gb);
960
if (s->pict_type == I_TYPE) {
962
} else if (s->pict_type == B_TYPE && mb_type >= 4) {
965
if (mb_type > 33 || svq3_decode_mb (h, mb_type)) {
966
av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
974
if (s->pict_type != B_TYPE && !s->low_delay) {
975
s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
976
(s->pict_type == P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
980
ff_draw_horiz_band(s, 16*s->mb_y, 16);
985
if (s->pict_type == B_TYPE || s->low_delay) {
986
*(AVFrame *) data = *(AVFrame *) &s->current_picture;
988
*(AVFrame *) data = *(AVFrame *) &s->last_picture;
991
avctx->frame_number = s->picture_number - 1;
993
/* dont output the last pic after seeking */
994
if (s->last_picture_ptr || s->low_delay) {
995
*data_size = sizeof(AVFrame);
1002
AVCodec svq3_decoder = {
1006
sizeof(H264Context),
1011
CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
added
removed
avidemux/ADM_lavcodec/svq3.c
