avcodec/pthread_frame: fix setting hwaccel with threads and get_format()
[ffmpeg.git] / libavcodec / rv30.c
1 /*
2  * RV30 decoder
3  * Copyright (c) 2007 Konstantin Shishkov
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  * RV30 decoder
25  */
26
27 #include "avcodec.h"
28 #include "mpegutils.h"
29 #include "mpegvideo.h"
30 #include "golomb.h"
31
32 #include "rv34.h"
33 #include "rv30data.h"
34
35
36 static int rv30_parse_slice_header(RV34DecContext *r, GetBitContext *gb, SliceInfo *si)
37 {
38     AVCodecContext *avctx = r->s.avctx;
39     int mb_bits;
40     int w = r->s.width, h = r->s.height;
41     int mb_size;
42     int rpr;
43
44     memset(si, 0, sizeof(SliceInfo));
45     if(get_bits(gb, 3))
46         return -1;
47     si->type = get_bits(gb, 2);
48     if(si->type == 1) si->type = 0;
49     if(get_bits1(gb))
50         return -1;
51     si->quant = get_bits(gb, 5);
52     skip_bits1(gb);
53     si->pts = get_bits(gb, 13);
54     rpr = get_bits(gb, av_log2(r->max_rpr) + 1);
55     if(rpr){
56         if (rpr > r->max_rpr) {
57             av_log(avctx, AV_LOG_ERROR, "rpr too large\n");
58             return AVERROR_INVALIDDATA;
59         }
60
61         if (avctx->extradata_size < rpr * 2 + 8) {
62             av_log(avctx, AV_LOG_ERROR,
63                    "Insufficient extradata - need at least %d bytes, got %d\n",
64                    8 + rpr * 2, avctx->extradata_size);
65             return AVERROR(EINVAL);
66         }
67
68         w = r->s.avctx->extradata[6 + rpr*2] << 2;
69         h = r->s.avctx->extradata[7 + rpr*2] << 2;
70     }
71     si->width  = w;
72     si->height = h;
73     mb_size = ((w + 15) >> 4) * ((h + 15) >> 4);
74     mb_bits = ff_rv34_get_start_offset(gb, mb_size);
75     si->start = get_bits(gb, mb_bits);
76     skip_bits1(gb);
77     return 0;
78 }
79
80 /**
81  * Decode 4x4 intra types array.
82  */
83 static int rv30_decode_intra_types(RV34DecContext *r, GetBitContext *gb, int8_t *dst)
84 {
85     int i, j, k;
86
87     for(i = 0; i < 4; i++, dst += r->intra_types_stride - 4){
88         for(j = 0; j < 4; j+= 2){
89             unsigned code = svq3_get_ue_golomb(gb) << 1;
90             if (code > 80U*2U) {
91                 av_log(r->s.avctx, AV_LOG_ERROR, "Incorrect intra prediction code\n");
92                 return -1;
93             }
94             for(k = 0; k < 2; k++){
95                 int A = dst[-r->intra_types_stride] + 1;
96                 int B = dst[-1] + 1;
97                 *dst++ = rv30_itype_from_context[A * 90 + B * 9 + rv30_itype_code[code + k]];
98                 if(dst[-1] == 9){
99                     av_log(r->s.avctx, AV_LOG_ERROR, "Incorrect intra prediction mode\n");
100                     return -1;
101                 }
102             }
103         }
104     }
105     return 0;
106 }
107
108 /**
109  * Decode macroblock information.
110  */
111 static int rv30_decode_mb_info(RV34DecContext *r)
112 {
113     static const int rv30_p_types[6] = { RV34_MB_SKIP, RV34_MB_P_16x16, RV34_MB_P_8x8, -1, RV34_MB_TYPE_INTRA, RV34_MB_TYPE_INTRA16x16 };
114     static const int rv30_b_types[6] = { RV34_MB_SKIP, RV34_MB_B_DIRECT, RV34_MB_B_FORWARD, RV34_MB_B_BACKWARD, RV34_MB_TYPE_INTRA, RV34_MB_TYPE_INTRA16x16 };
115     MpegEncContext *s = &r->s;
116     GetBitContext *gb = &s->gb;
117     unsigned code     = svq3_get_ue_golomb(gb);
118
119     if (code > 11) {
120         av_log(s->avctx, AV_LOG_ERROR, "Incorrect MB type code\n");
121         return -1;
122     }
123     if(code > 5){
124         av_log(s->avctx, AV_LOG_ERROR, "dquant needed\n");
125         code -= 6;
126     }
127     if(s->pict_type != AV_PICTURE_TYPE_B)
128         return rv30_p_types[code];
129     else
130         return rv30_b_types[code];
131 }
132
133 static inline void rv30_weak_loop_filter(uint8_t *src, const int step,
134                                          const int stride, const int lim)
135 {
136     const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;
137     int i, diff;
138
139     for(i = 0; i < 4; i++){
140         diff = ((src[-2*step] - src[1*step]) - (src[-1*step] - src[0*step])*4) >> 3;
141         diff = av_clip(diff, -lim, lim);
142         src[-1*step] = cm[src[-1*step] + diff];
143         src[ 0*step] = cm[src[ 0*step] - diff];
144         src += stride;
145     }
146 }
147
148 static void rv30_loop_filter(RV34DecContext *r, int row)
149 {
150     MpegEncContext *s = &r->s;
151     int mb_pos, mb_x;
152     int i, j, k;
153     uint8_t *Y, *C;
154     int loc_lim, cur_lim, left_lim = 0, top_lim = 0;
155
156     mb_pos = row * s->mb_stride;
157     for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
158         int mbtype = s->current_picture_ptr->mb_type[mb_pos];
159         if(IS_INTRA(mbtype) || IS_SEPARATE_DC(mbtype))
160             r->deblock_coefs[mb_pos] = 0xFFFF;
161         if(IS_INTRA(mbtype))
162             r->cbp_chroma[mb_pos] = 0xFF;
163     }
164
165     /* all vertical edges are filtered first
166      * and horizontal edges are filtered on the next iteration
167      */
168     mb_pos = row * s->mb_stride;
169     for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
170         cur_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos]];
171         if(mb_x)
172             left_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos - 1]];
173         for(j = 0; j < 16; j += 4){
174             Y = s->current_picture_ptr->f->data[0] + mb_x*16 + (row*16 + j) * s->linesize + 4 * !mb_x;
175             for(i = !mb_x; i < 4; i++, Y += 4){
176                 int ij = i + j;
177                 loc_lim = 0;
178                 if(r->deblock_coefs[mb_pos] & (1 << ij))
179                     loc_lim = cur_lim;
180                 else if(!i && r->deblock_coefs[mb_pos - 1] & (1 << (ij + 3)))
181                     loc_lim = left_lim;
182                 else if( i && r->deblock_coefs[mb_pos]     & (1 << (ij - 1)))
183                     loc_lim = cur_lim;
184                 if(loc_lim)
185                     rv30_weak_loop_filter(Y, 1, s->linesize, loc_lim);
186             }
187         }
188         for(k = 0; k < 2; k++){
189             int cur_cbp, left_cbp = 0;
190             cur_cbp = (r->cbp_chroma[mb_pos] >> (k*4)) & 0xF;
191             if(mb_x)
192                 left_cbp = (r->cbp_chroma[mb_pos - 1] >> (k*4)) & 0xF;
193             for(j = 0; j < 8; j += 4){
194                 C = s->current_picture_ptr->f->data[k + 1] + mb_x*8 + (row*8 + j) * s->uvlinesize + 4 * !mb_x;
195                 for(i = !mb_x; i < 2; i++, C += 4){
196                     int ij = i + (j >> 1);
197                     loc_lim = 0;
198                     if (cur_cbp & (1 << ij))
199                         loc_lim = cur_lim;
200                     else if(!i && left_cbp & (1 << (ij + 1)))
201                         loc_lim = left_lim;
202                     else if( i && cur_cbp  & (1 << (ij - 1)))
203                         loc_lim = cur_lim;
204                     if(loc_lim)
205                         rv30_weak_loop_filter(C, 1, s->uvlinesize, loc_lim);
206                 }
207             }
208         }
209     }
210     mb_pos = row * s->mb_stride;
211     for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
212         cur_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos]];
213         if(row)
214             top_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos - s->mb_stride]];
215         for(j = 4*!row; j < 16; j += 4){
216             Y = s->current_picture_ptr->f->data[0] + mb_x*16 + (row*16 + j) * s->linesize;
217             for(i = 0; i < 4; i++, Y += 4){
218                 int ij = i + j;
219                 loc_lim = 0;
220                 if(r->deblock_coefs[mb_pos] & (1 << ij))
221                     loc_lim = cur_lim;
222                 else if(!j && r->deblock_coefs[mb_pos - s->mb_stride] & (1 << (ij + 12)))
223                     loc_lim = top_lim;
224                 else if( j && r->deblock_coefs[mb_pos]                & (1 << (ij - 4)))
225                     loc_lim = cur_lim;
226                 if(loc_lim)
227                     rv30_weak_loop_filter(Y, s->linesize, 1, loc_lim);
228             }
229         }
230         for(k = 0; k < 2; k++){
231             int cur_cbp, top_cbp = 0;
232             cur_cbp = (r->cbp_chroma[mb_pos] >> (k*4)) & 0xF;
233             if(row)
234                 top_cbp = (r->cbp_chroma[mb_pos - s->mb_stride] >> (k*4)) & 0xF;
235             for(j = 4*!row; j < 8; j += 4){
236                 C = s->current_picture_ptr->f->data[k+1] + mb_x*8 + (row*8 + j) * s->uvlinesize;
237                 for(i = 0; i < 2; i++, C += 4){
238                     int ij = i + (j >> 1);
239                     loc_lim = 0;
240                     if (r->cbp_chroma[mb_pos] & (1 << ij))
241                         loc_lim = cur_lim;
242                     else if(!j && top_cbp & (1 << (ij + 2)))
243                         loc_lim = top_lim;
244                     else if( j && cur_cbp & (1 << (ij - 2)))
245                         loc_lim = cur_lim;
246                     if(loc_lim)
247                         rv30_weak_loop_filter(C, s->uvlinesize, 1, loc_lim);
248                 }
249             }
250         }
251     }
252 }
253
254 /**
255  * Initialize decoder.
256  */
257 static av_cold int rv30_decode_init(AVCodecContext *avctx)
258 {
259     RV34DecContext *r = avctx->priv_data;
260     int ret;
261
262     r->rv30 = 1;
263     if ((ret = ff_rv34_decode_init(avctx)) < 0)
264         return ret;
265     if(avctx->extradata_size < 2){
266         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
267         return -1;
268     }
269
270     r->max_rpr = avctx->extradata[1] & 7;
271     if(avctx->extradata_size < 2*r->max_rpr + 8){
272         av_log(avctx, AV_LOG_WARNING, "Insufficient extradata - need at least %d bytes, got %d\n",
273                2*r->max_rpr + 8, avctx->extradata_size);
274     }
275
276     r->parse_slice_header = rv30_parse_slice_header;
277     r->decode_intra_types = rv30_decode_intra_types;
278     r->decode_mb_info     = rv30_decode_mb_info;
279     r->loop_filter        = rv30_loop_filter;
280     r->luma_dc_quant_i = rv30_luma_dc_quant;
281     r->luma_dc_quant_p = rv30_luma_dc_quant;
282     return 0;
283 }
284
285 AVCodec ff_rv30_decoder = {
286     .name                  = "rv30",
287     .long_name             = NULL_IF_CONFIG_SMALL("RealVideo 3.0"),
288     .type                  = AVMEDIA_TYPE_VIDEO,
289     .id                    = AV_CODEC_ID_RV30,
290     .priv_data_size        = sizeof(RV34DecContext),
291     .init                  = rv30_decode_init,
292     .close                 = ff_rv34_decode_end,
293     .decode                = ff_rv34_decode_frame,
294     .capabilities          = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
295                              CODEC_CAP_FRAME_THREADS,
296     .flush                 = ff_mpeg_flush,
297     .pix_fmts              = (const enum AVPixelFormat[]) {
298         AV_PIX_FMT_YUV420P,
299         AV_PIX_FMT_NONE
300     },
301     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(ff_rv34_decode_init_thread_copy),
302     .update_thread_context = ONLY_IF_THREADS_ENABLED(ff_rv34_decode_update_thread_context),
303 };