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
h261dec.c
Go to the documentation of this file.
1
/*
2
* H261 decoder
3
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
4
* Copyright (c) 2004 Maarten Daniels
5
*
6
* This file is part of FFmpeg.
7
*
8
* FFmpeg is free software; you can redistribute it and/or
9
* modify it under the terms of the GNU Lesser General Public
10
* License as published by the Free Software Foundation; either
11
* version 2.1 of the License, or (at your option) any later version.
12
*
13
* FFmpeg is distributed in the hope that it will be useful,
14
* but WITHOUT ANY WARRANTY; without even the implied warranty of
15
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16
* Lesser General Public License for more details.
17
*
18
* You should have received a copy of the GNU Lesser General Public
19
* License along with FFmpeg; if not, write to the Free Software
20
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
*/
22
23
/**
24
* @file
25
* H.261 decoder.
26
*/
27
28
#include "
libavutil/avassert.h
"
29
#include "
avcodec.h
"
30
#include "
mpeg_er.h
"
31
#include "
mpegutils.h
"
32
#include "
mpegvideo.h
"
33
#include "
h263.h
"
34
#include "
h261.h
"
35
#include "
internal.h
"
36
37
#define H261_MBA_VLC_BITS 9
38
#define H261_MTYPE_VLC_BITS 6
39
#define H261_MV_VLC_BITS 7
40
#define H261_CBP_VLC_BITS 9
41
#define TCOEFF_VLC_BITS 9
42
#define MBA_STUFFING 33
43
#define MBA_STARTCODE 34
44
45
static
VLC
h261_mba_vlc
;
46
static
VLC
h261_mtype_vlc
;
47
static
VLC
h261_mv_vlc
;
48
static
VLC
h261_cbp_vlc
;
49
50
static
av_cold
void
h261_decode_init_vlc
(
H261Context
*h)
51
{
52
static
int
done = 0;
53
54
if
(!done) {
55
done = 1;
56
INIT_VLC_STATIC
(&h261_mba_vlc,
H261_MBA_VLC_BITS
, 35,
57
ff_h261_mba_bits
, 1, 1,
58
ff_h261_mba_code
, 1, 1, 662);
59
INIT_VLC_STATIC
(&h261_mtype_vlc,
H261_MTYPE_VLC_BITS
, 10,
60
ff_h261_mtype_bits
, 1, 1,
61
ff_h261_mtype_code
, 1, 1, 80);
62
INIT_VLC_STATIC
(&h261_mv_vlc,
H261_MV_VLC_BITS
, 17,
63
&
ff_h261_mv_tab
[0][1], 2, 1,
64
&
ff_h261_mv_tab
[0][0], 2, 1, 144);
65
INIT_VLC_STATIC
(&h261_cbp_vlc,
H261_CBP_VLC_BITS
, 63,
66
&
ff_h261_cbp_tab
[0][1], 2, 1,
67
&
ff_h261_cbp_tab
[0][0], 2, 1, 512);
68
INIT_VLC_RL
(
ff_h261_rl_tcoeff
, 552);
69
}
70
}
71
72
static
av_cold
int
h261_decode_init
(
AVCodecContext
*avctx)
73
{
74
H261Context
*h = avctx->
priv_data
;
75
MpegEncContext
*
const
s
= &h->
s
;
76
77
// set defaults
78
ff_mpv_decode_defaults
(s);
79
ff_mpv_decode_init
(s, avctx);
80
81
s->
out_format
=
FMT_H261
;
82
s->
low_delay
= 1;
83
avctx->
pix_fmt
=
AV_PIX_FMT_YUV420P
;
84
85
ff_h261_common_init
();
86
h261_decode_init_vlc
(h);
87
88
h->
gob_start_code_skipped
= 0;
89
90
return
0;
91
}
92
93
/**
94
* Decode the group of blocks header or slice header.
95
* @return <0 if an error occurred
96
*/
97
static
int
h261_decode_gob_header
(
H261Context
*h)
98
{
99
unsigned
int
val
;
100
MpegEncContext
*
const
s
= &h->
s
;
101
102
if
(!h->
gob_start_code_skipped
) {
103
/* Check for GOB Start Code */
104
val =
show_bits
(&s->
gb
, 15);
105
if
(val)
106
return
-1;
107
108
/* We have a GBSC */
109
skip_bits
(&s->
gb
, 16);
110
}
111
112
h->
gob_start_code_skipped
= 0;
113
114
h->
gob_number
=
get_bits
(&s->
gb
, 4);
/* GN */
115
s->
qscale
=
get_bits
(&s->
gb
, 5);
/* GQUANT */
116
117
/* Check if gob_number is valid */
118
if
(s->
mb_height
== 18) {
// CIF
119
if
((h->
gob_number
<= 0) || (h->
gob_number
> 12))
120
return
-1;
121
}
else
{
// QCIF
122
if
((h->
gob_number
!= 1) && (h->
gob_number
!= 3) &&
123
(h->
gob_number
!= 5))
124
return
-1;
125
}
126
127
/* GEI */
128
if
(
skip_1stop_8data_bits
(&s->
gb
) < 0)
129
return
AVERROR_INVALIDDATA
;
130
131
if
(s->
qscale
== 0) {
132
av_log
(s->
avctx
,
AV_LOG_ERROR
,
"qscale has forbidden 0 value\n"
);
133
if
(s->
avctx
->
err_recognition
& (
AV_EF_BITSTREAM
|
AV_EF_COMPLIANT
))
134
return
-1;
135
}
136
137
/* For the first transmitted macroblock in a GOB, MBA is the absolute
138
* address. For subsequent macroblocks, MBA is the difference between
139
* the absolute addresses of the macroblock and the last transmitted
140
* macroblock. */
141
h->
current_mba
= 0;
142
h->
mba_diff
= 0;
143
144
return
0;
145
}
146
147
/**
148
* Decode the group of blocks / video packet header.
149
* @return <0 if no resync found
150
*/
151
static
int
h261_resync
(
H261Context
*h)
152
{
153
MpegEncContext
*
const
s
= &h->
s
;
154
int
left,
ret
;
155
156
if
(h->
gob_start_code_skipped
) {
157
ret =
h261_decode_gob_header
(h);
158
if
(ret >= 0)
159
return
0;
160
}
else
{
161
if
(
show_bits
(&s->
gb
, 15) == 0) {
162
ret =
h261_decode_gob_header
(h);
163
if
(ret >= 0)
164
return
0;
165
}
166
// OK, it is not where it is supposed to be ...
167
s->
gb
= s->
last_resync_gb
;
168
align_get_bits
(&s->
gb
);
169
left =
get_bits_left
(&s->
gb
);
170
171
for
(; left > 15 + 1 + 4 + 5; left -= 8) {
172
if
(
show_bits
(&s->
gb
, 15) == 0) {
173
GetBitContext
bak = s->
gb
;
174
175
ret =
h261_decode_gob_header
(h);
176
if
(ret >= 0)
177
return
0;
178
179
s->
gb
= bak;
180
}
181
skip_bits
(&s->
gb
, 8);
182
}
183
}
184
185
return
-1;
186
}
187
188
/**
189
* Decode skipped macroblocks.
190
* @return 0
191
*/
192
static
int
h261_decode_mb_skipped
(
H261Context
*h,
int
mba1,
int
mba2)
193
{
194
MpegEncContext
*
const
s
= &h->
s
;
195
int
i;
196
197
s->
mb_intra
= 0;
198
199
for
(i = mba1; i < mba2; i++) {
200
int
j, xy;
201
202
s->
mb_x
= ((h->
gob_number
- 1) % 2) * 11 + i % 11;
203
s->
mb_y
= ((h->
gob_number
- 1) / 2) * 3 + i / 11;
204
xy = s->
mb_x
+ s->
mb_y
* s->
mb_stride
;
205
ff_init_block_index
(s);
206
ff_update_block_index
(s);
207
208
for
(j = 0; j < 6; j++)
209
s->
block_last_index
[j] = -1;
210
211
s->
mv_dir
=
MV_DIR_FORWARD
;
212
s->
mv_type
=
MV_TYPE_16X16
;
213
s->
current_picture
.
mb_type
[xy] =
MB_TYPE_SKIP
|
MB_TYPE_16x16
|
MB_TYPE_L0
;
214
s->
mv
[0][0][0] = 0;
215
s->
mv
[0][0][1] = 0;
216
s->
mb_skipped
= 1;
217
h->
mtype
&= ~
MB_TYPE_H261_FIL
;
218
219
if
(s->
current_picture
.
motion_val
[0]) {
220
int
b_stride = 2*s->
mb_width
+ 1;
221
int
b_xy = 2 * s->
mb_x
+ (2 * s->
mb_y
) * b_stride;
222
s->
current_picture
.
motion_val
[0][b_xy][0] = s->
mv
[0][0][0];
223
s->
current_picture
.
motion_val
[0][b_xy][1] = s->
mv
[0][0][1];
224
}
225
226
ff_mpv_decode_mb
(s, s->
block
);
227
}
228
229
return
0;
230
}
231
232
static
const
int
mvmap
[17] = {
233
0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16
234
};
235
236
static
int
decode_mv_component
(
GetBitContext
*gb,
int
v
)
237
{
238
int
mv_diff =
get_vlc2
(gb, h261_mv_vlc.
table
,
H261_MV_VLC_BITS
, 2);
239
240
/* check if mv_diff is valid */
241
if
(mv_diff < 0)
242
return
v
;
243
244
mv_diff =
mvmap
[mv_diff];
245
246
if
(mv_diff && !
get_bits1
(gb))
247
mv_diff = -mv_diff;
248
249
v += mv_diff;
250
if
(v <= -16)
251
v += 32;
252
else
if
(v >= 16)
253
v -= 32;
254
255
return
v
;
256
}
257
258
/**
259
* Decode a macroblock.
260
* @return <0 if an error occurred
261
*/
262
static
int
h261_decode_block
(
H261Context
*h, int16_t *
block
,
int
n
,
int
coded)
263
{
264
MpegEncContext
*
const
s
= &h->
s
;
265
int
level
, i, j,
run
;
266
RLTable
*rl = &
ff_h261_rl_tcoeff
;
267
const
uint8_t
*scan_table;
268
269
/* For the variable length encoding there are two code tables, one being
270
* used for the first transmitted LEVEL in INTER, INTER + MC and
271
* INTER + MC + FIL blocks, the second for all other LEVELs except the
272
* first one in INTRA blocks which is fixed length coded with 8 bits.
273
* NOTE: The two code tables only differ in one VLC so we handle that
274
* manually. */
275
scan_table = s->
intra_scantable
.
permutated
;
276
if
(s->
mb_intra
) {
277
/* DC coef */
278
level =
get_bits
(&s->
gb
, 8);
279
// 0 (00000000b) and -128 (10000000b) are FORBIDDEN
280
if
((level & 0x7F) == 0) {
281
av_log
(s->
avctx
,
AV_LOG_ERROR
,
"illegal dc %d at %d %d\n"
,
282
level, s->
mb_x
, s->
mb_y
);
283
return
-1;
284
}
285
/* The code 1000 0000 is not used, the reconstruction level of 1024
286
* being coded as 1111 1111. */
287
if
(level == 255)
288
level = 128;
289
block[0] =
level
;
290
i = 1;
291
}
else
if
(coded) {
292
// Run Level Code
293
// EOB Not possible for first level when cbp is available (that's why the table is different)
294
// 0 1 1s
295
// * * 0*
296
int
check
=
show_bits
(&s->
gb
, 2);
297
i = 0;
298
if
(check & 0x2) {
299
skip_bits
(&s->
gb
, 2);
300
block[0] = (check & 0x1) ? -1 : 1;
301
i = 1;
302
}
303
}
else
{
304
i = 0;
305
}
306
if
(!coded) {
307
s->
block_last_index
[
n
] = i - 1;
308
return
0;
309
}
310
{
311
OPEN_READER
(
re
, &s->
gb
);
312
i--;
// offset by -1 to allow direct indexing of scan_table
313
for
(;;) {
314
UPDATE_CACHE
(
re
, &s->
gb
);
315
GET_RL_VLC
(level, run,
re
, &s->
gb
, rl->
rl_vlc
[0],
TCOEFF_VLC_BITS
, 2, 0);
316
if
(run == 66) {
317
if
(level) {
318
CLOSE_READER
(
re
, &s->
gb
);
319
av_log
(s->
avctx
,
AV_LOG_ERROR
,
"illegal ac vlc code at %dx%d\n"
,
320
s->
mb_x
, s->
mb_y
);
321
return
-1;
322
}
323
/* escape */
324
/* The remaining combinations of (run, level) are encoded with a
325
* 20-bit word consisting of 6 bits escape, 6 bits run and 8 bits
326
* level. */
327
run =
SHOW_UBITS
(
re
, &s->
gb
, 6) + 1;
328
SKIP_CACHE
(
re
, &s->
gb
, 6);
329
level =
SHOW_SBITS
(
re
, &s->
gb
, 8);
330
SKIP_COUNTER
(
re
, &s->
gb
, 6 + 8);
331
}
else
if
(level == 0) {
332
break
;
333
}
else
{
334
if
(
SHOW_UBITS
(
re
, &s->
gb
, 1))
335
level = -
level
;
336
SKIP_COUNTER
(
re
, &s->
gb
, 1);
337
}
338
i +=
run
;
339
if
(i >= 64) {
340
CLOSE_READER
(
re
, &s->
gb
);
341
av_log
(s->
avctx
,
AV_LOG_ERROR
,
"run overflow at %dx%d\n"
,
342
s->
mb_x
, s->
mb_y
);
343
return
-1;
344
}
345
j = scan_table[i];
346
block[j] =
level
;
347
}
348
CLOSE_READER
(
re
, &s->
gb
);
349
}
350
s->
block_last_index
[
n
] = i;
351
return
0;
352
}
353
354
static
int
h261_decode_mb
(
H261Context
*h)
355
{
356
MpegEncContext
*
const
s
= &h->
s
;
357
int
i, cbp, xy;
358
359
cbp = 63;
360
// Read mba
361
do
{
362
h->
mba_diff
=
get_vlc2
(&s->
gb
, h261_mba_vlc.
table
,
363
H261_MBA_VLC_BITS
, 2);
364
365
/* Check for slice end */
366
/* NOTE: GOB can be empty (no MB data) or exist only of MBA_stuffing */
367
if
(h->
mba_diff
==
MBA_STARTCODE
) {
// start code
368
h->
gob_start_code_skipped
= 1;
369
return
SLICE_END
;
370
}
371
}
while
(h->
mba_diff
==
MBA_STUFFING
);
// stuffing
372
373
if
(h->
mba_diff
< 0) {
374
if
(
get_bits_left
(&s->
gb
) <= 7)
375
return
SLICE_END
;
376
377
av_log
(s->
avctx
,
AV_LOG_ERROR
,
"illegal mba at %d %d\n"
, s->
mb_x
, s->
mb_y
);
378
return
SLICE_ERROR
;
379
}
380
381
h->
mba_diff
+= 1;
382
h->
current_mba
+= h->
mba_diff
;
383
384
if
(h->
current_mba
>
MBA_STUFFING
)
385
return
SLICE_ERROR
;
386
387
s->
mb_x
= ((h->
gob_number
- 1) % 2) * 11 + ((h->
current_mba
- 1) % 11);
388
s->
mb_y
= ((h->
gob_number
- 1) / 2) * 3 + ((h->
current_mba
- 1) / 11);
389
xy = s->
mb_x
+ s->
mb_y
* s->
mb_stride
;
390
ff_init_block_index
(s);
391
ff_update_block_index
(s);
392
393
// Read mtype
394
h->
mtype
=
get_vlc2
(&s->
gb
, h261_mtype_vlc.
table
,
H261_MTYPE_VLC_BITS
, 2);
395
if
(h->
mtype
< 0) {
396
av_log
(s->
avctx
,
AV_LOG_ERROR
,
"Invalid mtype index %d\n"
,
397
h->
mtype
);
398
return
SLICE_ERROR
;
399
}
400
av_assert0
(h->
mtype
<
FF_ARRAY_ELEMS
(
ff_h261_mtype_map
));
401
h->
mtype
=
ff_h261_mtype_map
[h->
mtype
];
402
403
// Read mquant
404
if
(
IS_QUANT
(h->
mtype
))
405
ff_set_qscale
(s,
get_bits
(&s->
gb
, 5));
406
407
s->
mb_intra
=
IS_INTRA4x4
(h->
mtype
);
408
409
// Read mv
410
if
(
IS_16X16
(h->
mtype
)) {
411
/* Motion vector data is included for all MC macroblocks. MVD is
412
* obtained from the macroblock vector by subtracting the vector
413
* of the preceding macroblock. For this calculation the vector
414
* of the preceding macroblock is regarded as zero in the
415
* following three situations:
416
* 1) evaluating MVD for macroblocks 1, 12 and 23;
417
* 2) evaluating MVD for macroblocks in which MBA does not represent a difference of 1;
418
* 3) MTYPE of the previous macroblock was not MC. */
419
if
((h->
current_mba
== 1) || (h->
current_mba
== 12) ||
420
(h->
current_mba
== 23) || (h->
mba_diff
!= 1)) {
421
h->
current_mv_x
= 0;
422
h->
current_mv_y
= 0;
423
}
424
425
h->
current_mv_x
=
decode_mv_component
(&s->
gb
, h->
current_mv_x
);
426
h->
current_mv_y
=
decode_mv_component
(&s->
gb
, h->
current_mv_y
);
427
}
else
{
428
h->
current_mv_x
= 0;
429
h->
current_mv_y
= 0;
430
}
431
432
// Read cbp
433
if
(
HAS_CBP
(h->
mtype
))
434
cbp =
get_vlc2
(&s->
gb
, h261_cbp_vlc.
table
,
H261_CBP_VLC_BITS
, 2) + 1;
435
436
if
(s->
mb_intra
) {
437
s->
current_picture
.
mb_type
[xy] =
MB_TYPE_INTRA
;
438
goto
intra;
439
}
440
441
//set motion vectors
442
s->
mv_dir
=
MV_DIR_FORWARD
;
443
s->
mv_type
=
MV_TYPE_16X16
;
444
s->
current_picture
.
mb_type
[xy] =
MB_TYPE_16x16
|
MB_TYPE_L0
;
445
s->
mv
[0][0][0] = h->
current_mv_x
* 2;
// gets divided by 2 in motion compensation
446
s->
mv
[0][0][1] = h->
current_mv_y
* 2;
447
448
if
(s->
current_picture
.
motion_val
[0]) {
449
int
b_stride = 2*s->
mb_width
+ 1;
450
int
b_xy = 2 * s->
mb_x
+ (2 * s->
mb_y
) * b_stride;
451
s->
current_picture
.
motion_val
[0][b_xy][0] = s->
mv
[0][0][0];
452
s->
current_picture
.
motion_val
[0][b_xy][1] = s->
mv
[0][0][1];
453
}
454
455
intra:
456
/* decode each block */
457
if
(s->
mb_intra
||
HAS_CBP
(h->
mtype
)) {
458
s->
bdsp
.
clear_blocks
(s->
block
[0]);
459
for
(i = 0; i < 6; i++) {
460
if
(
h261_decode_block
(h, s->
block
[i], i, cbp & 32) < 0)
461
return
SLICE_ERROR
;
462
cbp += cbp;
463
}
464
}
else
{
465
for
(i = 0; i < 6; i++)
466
s->
block_last_index
[i] = -1;
467
}
468
469
ff_mpv_decode_mb
(s, s->
block
);
470
471
return
SLICE_OK
;
472
}
473
474
/**
475
* Decode the H.261 picture header.
476
* @return <0 if no startcode found
477
*/
478
static
int
h261_decode_picture_header
(
H261Context
*h)
479
{
480
MpegEncContext
*
const
s
= &h->
s
;
481
int
format, i;
482
uint32_t startcode = 0;
483
484
for
(i =
get_bits_left
(&s->
gb
); i > 24; i -= 1) {
485
startcode = ((startcode << 1) |
get_bits
(&s->
gb
, 1)) & 0x000FFFFF;
486
487
if
(startcode == 0x10)
488
break
;
489
}
490
491
if
(startcode != 0x10) {
492
av_log
(s->
avctx
,
AV_LOG_ERROR
,
"Bad picture start code\n"
);
493
return
-1;
494
}
495
496
/* temporal reference */
497
i =
get_bits
(&s->
gb
, 5);
/* picture timestamp */
498
if
(i < (s->
picture_number
& 31))
499
i += 32;
500
s->
picture_number
= (s->
picture_number
& ~31) + i;
501
502
s->
avctx
->
framerate
= (
AVRational
) { 30000, 1001 };
503
504
/* PTYPE starts here */
505
skip_bits1
(&s->
gb
);
/* split screen off */
506
skip_bits1
(&s->
gb
);
/* camera off */
507
skip_bits1
(&s->
gb
);
/* freeze picture release off */
508
509
format =
get_bits1
(&s->
gb
);
510
511
// only 2 formats possible
512
if
(format == 0) {
// QCIF
513
s->
width
= 176;
514
s->
height
= 144;
515
s->
mb_width
= 11;
516
s->
mb_height
= 9;
517
}
else
{
// CIF
518
s->
width
= 352;
519
s->
height
= 288;
520
s->
mb_width
= 22;
521
s->
mb_height
= 18;
522
}
523
524
s->
mb_num
= s->
mb_width
* s->
mb_height
;
525
526
skip_bits1
(&s->
gb
);
/* still image mode off */
527
skip_bits1
(&s->
gb
);
/* Reserved */
528
529
/* PEI */
530
if
(
skip_1stop_8data_bits
(&s->
gb
) < 0)
531
return
AVERROR_INVALIDDATA
;
532
533
/* H.261 has no I-frames, but if we pass AV_PICTURE_TYPE_I for the first
534
* frame, the codec crashes if it does not contain all I-blocks
535
* (e.g. when a packet is lost). */
536
s->
pict_type
=
AV_PICTURE_TYPE_P
;
537
538
h->
gob_number
= 0;
539
return
0;
540
}
541
542
static
int
h261_decode_gob
(
H261Context
*h)
543
{
544
MpegEncContext
*
const
s
= &h->
s
;
545
546
ff_set_qscale
(s, s->
qscale
);
547
548
/* decode mb's */
549
while
(h->
current_mba
<=
MBA_STUFFING
) {
550
int
ret
;
551
/* DCT & quantize */
552
ret =
h261_decode_mb
(h);
553
if
(ret < 0) {
554
if
(ret ==
SLICE_END
) {
555
h261_decode_mb_skipped
(h, h->
current_mba
, 33);
556
return
0;
557
}
558
av_log
(s->
avctx
,
AV_LOG_ERROR
,
"Error at MB: %d\n"
,
559
s->
mb_x
+ s->
mb_y
* s->
mb_stride
);
560
return
-1;
561
}
562
563
h261_decode_mb_skipped
(h,
564
h->
current_mba
- h->
mba_diff
,
565
h->
current_mba
- 1);
566
}
567
568
return
-1;
569
}
570
571
/**
572
* returns the number of bytes consumed for building the current frame
573
*/
574
static
int
get_consumed_bytes
(
MpegEncContext
*
s
,
int
buf_size)
575
{
576
int
pos =
get_bits_count
(&s->
gb
) >> 3;
577
if
(pos == 0)
578
pos = 1;
// avoid infinite loops (i doubt that is needed but ...)
579
if
(pos + 10 > buf_size)
580
pos = buf_size;
// oops ;)
581
582
return
pos;
583
}
584
585
static
int
h261_decode_frame
(
AVCodecContext
*avctx,
void
*
data
,
586
int
*got_frame,
AVPacket
*avpkt)
587
{
588
const
uint8_t
*
buf
= avpkt->
data
;
589
int
buf_size = avpkt->
size
;
590
H261Context
*h = avctx->
priv_data
;
591
MpegEncContext
*
s
= &h->
s
;
592
int
ret
;
593
AVFrame
*pict =
data
;
594
595
av_dlog
(avctx,
"*****frame %d size=%d\n"
, avctx->
frame_number
, buf_size);
596
av_dlog
(avctx,
"bytes=%x %x %x %x\n"
, buf[0], buf[1], buf[2], buf[3]);
597
s->
flags
= avctx->
flags
;
598
s->
flags2
= avctx->
flags2
;
599
600
h->
gob_start_code_skipped
= 0;
601
602
retry:
603
init_get_bits
(&s->
gb
, buf, buf_size * 8);
604
605
if
(!s->
context_initialized
)
606
// we need the IDCT permutaton for reading a custom matrix
607
ff_mpv_idct_init
(s);
608
609
ret =
h261_decode_picture_header
(h);
610
611
/* skip if the header was thrashed */
612
if
(ret < 0) {
613
av_log
(s->
avctx
,
AV_LOG_ERROR
,
"header damaged\n"
);
614
return
-1;
615
}
616
617
if
(s->
width
!= avctx->
coded_width
|| s->
height
!= avctx->
coded_height
) {
618
ParseContext
pc = s->
parse_context
;
// FIXME move this demuxing hack to libavformat
619
s->
parse_context
.
buffer
= 0;
620
ff_mpv_common_end
(s);
621
s->
parse_context
= pc;
622
}
623
624
if
(!s->
context_initialized
) {
625
if
((ret =
ff_mpv_common_init
(s)) < 0)
626
return
ret
;
627
628
ret =
ff_set_dimensions
(avctx, s->
width
, s->
height
);
629
if
(ret < 0)
630
return
ret
;
631
632
goto
retry;
633
}
634
635
// for skipping the frame
636
s->
current_picture
.
f
->
pict_type
= s->
pict_type
;
637
s->
current_picture
.
f
->
key_frame
= s->
pict_type
==
AV_PICTURE_TYPE_I
;
638
639
if
((avctx->
skip_frame
>=
AVDISCARD_NONREF
&& s->
pict_type
==
AV_PICTURE_TYPE_B
) ||
640
(avctx->
skip_frame
>=
AVDISCARD_NONKEY
&& s->
pict_type
!=
AV_PICTURE_TYPE_I
) ||
641
avctx->
skip_frame
>=
AVDISCARD_ALL
)
642
return
get_consumed_bytes
(s, buf_size);
643
644
if
(
ff_mpv_frame_start
(s, avctx) < 0)
645
return
-1;
646
647
ff_mpeg_er_frame_start
(s);
648
649
/* decode each macroblock */
650
s->
mb_x
= 0;
651
s->
mb_y
= 0;
652
653
while
(h->
gob_number
< (s->
mb_height
== 18 ? 12 : 5)) {
654
if
(
h261_resync
(h) < 0)
655
break
;
656
h261_decode_gob
(h);
657
}
658
ff_mpv_frame_end
(s);
659
660
av_assert0
(s->
current_picture
.
f
->
pict_type
== s->
current_picture_ptr
->
f
->
pict_type
);
661
av_assert0
(s->
current_picture
.
f
->
pict_type
== s->
pict_type
);
662
663
if
((ret =
av_frame_ref
(pict, s->
current_picture_ptr
->
f
)) < 0)
664
return
ret
;
665
ff_print_debug_info
(s, s->
current_picture_ptr
, pict);
666
667
*got_frame = 1;
668
669
return
get_consumed_bytes
(s, buf_size);
670
}
671
672
static
av_cold
int
h261_decode_end
(
AVCodecContext
*avctx)
673
{
674
H261Context
*h = avctx->
priv_data
;
675
MpegEncContext
*
s
= &h->
s
;
676
677
ff_mpv_common_end
(s);
678
return
0;
679
}
680
681
AVCodec
ff_h261_decoder
= {
682
.
name
=
"h261"
,
683
.long_name =
NULL_IF_CONFIG_SMALL
(
"H.261"
),
684
.type =
AVMEDIA_TYPE_VIDEO
,
685
.id =
AV_CODEC_ID_H261
,
686
.priv_data_size =
sizeof
(
H261Context
),
687
.
init
=
h261_decode_init
,
688
.close =
h261_decode_end
,
689
.
decode
=
h261_decode_frame
,
690
.capabilities =
CODEC_CAP_DR1
,
691
.max_lowres = 3,
692
};
Generated on Sun Mar 8 2015 02:34:52 for FFmpeg by
1.8.2