Remove useless test.
[ffmpeg.git] / libavcodec / indeo3.c
1 /*
2  * Intel Indeo 3 (IV31, IV32, etc.) video decoder for ffmpeg
3  * written, produced, and directed by Alan Smithee
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 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <unistd.h>
26
27 #include "avcodec.h"
28 #include "dsputil.h"
29 #include "bytestream.h"
30
31 #include "indeo3data.h"
32
33 typedef struct
34 {
35   uint8_t *Ybuf;
36   uint8_t *Ubuf;
37   uint8_t *Vbuf;
38   uint8_t *the_buf;
39   unsigned int the_buf_size;
40   unsigned short y_w, y_h;
41   unsigned short uv_w, uv_h;
42 } YUVBufs;
43
44 typedef struct Indeo3DecodeContext {
45     AVCodecContext *avctx;
46     int width, height;
47     AVFrame frame;
48
49     YUVBufs iv_frame[2];
50     YUVBufs *cur_frame;
51     YUVBufs *ref_frame;
52
53     uint8_t *ModPred;
54     uint8_t *corrector_type;
55 } Indeo3DecodeContext;
56
57 static const uint8_t corrector_type_0[24] = {
58   195, 159, 133, 115, 101,  93,  87,  77,
59   195, 159, 133, 115, 101,  93,  87,  77,
60   128,  79,  79,  79,  79,  79,  79,  79
61 };
62
63 static const uint8_t corrector_type_2[8] = { 9, 7, 6, 8, 5, 4, 3, 2 };
64
65 static av_cold void build_modpred(Indeo3DecodeContext *s)
66 {
67   int i, j;
68
69   s->ModPred = av_malloc(8 * 128);
70
71   for (i=0; i < 128; ++i) {
72     s->ModPred[i+0*128] = i >  126 ? 254 : 2*(i + 1 - ((i + 1) % 2));
73     s->ModPred[i+1*128] = i ==   7 ?  20 :
74                           i == 119 ||
75                           i == 120 ? 236 : 2*(i + 2 - ((i + 1) % 3));
76     s->ModPred[i+2*128] = i >  125 ? 248 : 2*(i + 2 - ((i + 2) % 4));
77     s->ModPred[i+3*128] =                  2*(i + 1 - ((i - 3) % 5));
78     s->ModPred[i+4*128] = i ==   8 ?  20 : 2*(i + 1 - ((i - 3) % 6));
79     s->ModPred[i+5*128] =                  2*(i + 4 - ((i + 3) % 7));
80     s->ModPred[i+6*128] = i >  123 ? 240 : 2*(i + 4 - ((i + 4) % 8));
81     s->ModPred[i+7*128] =                  2*(i + 5 - ((i + 4) % 9));
82   }
83
84   s->corrector_type = av_malloc(24 * 256);
85
86   for (i=0; i < 24; ++i) {
87     for (j=0; j < 256; ++j) {
88       s->corrector_type[i*256+j] = j < corrector_type_0[i]          ? 1 :
89                                    j < 248 || (i == 16 && j == 248) ? 0 :
90                                    corrector_type_2[j - 248];
91     }
92   }
93 }
94
95 static void iv_Decode_Chunk(Indeo3DecodeContext *s, uint8_t *cur,
96   uint8_t *ref, int width, int height, const uint8_t *buf1,
97   long fflags2, const uint8_t *hdr,
98   const uint8_t *buf2, int min_width_160);
99
100 /* ---------------------------------------------------------------------- */
101 static av_cold void iv_alloc_frames(Indeo3DecodeContext *s)
102 {
103   int luma_width, luma_height, luma_pixels, chroma_width, chroma_height,
104       chroma_pixels, i;
105   unsigned int bufsize;
106
107   luma_width   = (s->width  + 3) & (~3);
108   luma_height  = (s->height + 3) & (~3);
109
110   s->iv_frame[0].y_w = s->iv_frame[0].y_h =
111     s->iv_frame[0].the_buf_size = 0;
112   s->iv_frame[1].y_w = s->iv_frame[1].y_h =
113     s->iv_frame[1].the_buf_size = 0;
114   s->iv_frame[1].the_buf = NULL;
115
116   chroma_width  = ((luma_width >> 2) + 3) & (~3);
117   chroma_height = ((luma_height>> 2) + 3) & (~3);
118   luma_pixels = luma_width * luma_height;
119   chroma_pixels = chroma_width * chroma_height;
120
121   bufsize = luma_pixels * 2 + luma_width * 3 +
122     (chroma_pixels + chroma_width) * 4;
123
124   if(!(s->iv_frame[0].the_buf = av_malloc(bufsize)))
125     return;
126   s->iv_frame[0].y_w = s->iv_frame[1].y_w = luma_width;
127   s->iv_frame[0].y_h = s->iv_frame[1].y_h = luma_height;
128   s->iv_frame[0].uv_w = s->iv_frame[1].uv_w = chroma_width;
129   s->iv_frame[0].uv_h = s->iv_frame[1].uv_h = chroma_height;
130   s->iv_frame[0].the_buf_size = bufsize;
131
132   s->iv_frame[0].Ybuf = s->iv_frame[0].the_buf + luma_width;
133   i = luma_pixels + luma_width * 2;
134   s->iv_frame[1].Ybuf = s->iv_frame[0].the_buf + i;
135   i += (luma_pixels + luma_width);
136   s->iv_frame[0].Ubuf = s->iv_frame[0].the_buf + i;
137   i += (chroma_pixels + chroma_width);
138   s->iv_frame[1].Ubuf = s->iv_frame[0].the_buf + i;
139   i += (chroma_pixels + chroma_width);
140   s->iv_frame[0].Vbuf = s->iv_frame[0].the_buf + i;
141   i += (chroma_pixels + chroma_width);
142   s->iv_frame[1].Vbuf = s->iv_frame[0].the_buf + i;
143
144   for(i = 1; i <= luma_width; i++)
145     s->iv_frame[0].Ybuf[-i] = s->iv_frame[1].Ybuf[-i] =
146       s->iv_frame[0].Ubuf[-i] = 0x80;
147
148   for(i = 1; i <= chroma_width; i++) {
149     s->iv_frame[1].Ubuf[-i] = 0x80;
150     s->iv_frame[0].Vbuf[-i] = 0x80;
151     s->iv_frame[1].Vbuf[-i] = 0x80;
152     s->iv_frame[1].Vbuf[chroma_pixels+i-1] = 0x80;
153   }
154 }
155
156 /* ---------------------------------------------------------------------- */
157 static av_cold void iv_free_func(Indeo3DecodeContext *s)
158 {
159   int i;
160
161   for(i = 0 ; i < 2 ; i++) {
162     if(s->iv_frame[i].the_buf != NULL)
163       av_free(s->iv_frame[i].the_buf);
164     s->iv_frame[i].Ybuf = s->iv_frame[i].Ubuf =
165       s->iv_frame[i].Vbuf = NULL;
166     s->iv_frame[i].the_buf = NULL;
167     s->iv_frame[i].the_buf_size = 0;
168     s->iv_frame[i].y_w = s->iv_frame[i].y_h = 0;
169     s->iv_frame[i].uv_w = s->iv_frame[i].uv_h = 0;
170   }
171
172   av_free(s->ModPred);
173   av_free(s->corrector_type);
174 }
175
176 /* ---------------------------------------------------------------------- */
177 static unsigned long iv_decode_frame(Indeo3DecodeContext *s,
178                                      const uint8_t *buf, int buf_size)
179 {
180   unsigned int hdr_width, hdr_height,
181     chroma_width, chroma_height;
182   unsigned long fflags1, fflags2, fflags3, offs1, offs2, offs3, offs;
183   const uint8_t *hdr_pos, *buf_pos;
184
185   buf_pos = buf;
186   buf_pos += 18;
187
188   fflags1 = bytestream_get_le16(&buf_pos);
189   fflags3 = bytestream_get_le32(&buf_pos);
190   fflags2 = *buf_pos++;
191   buf_pos += 3;
192   hdr_height = bytestream_get_le16(&buf_pos);
193   hdr_width  = bytestream_get_le16(&buf_pos);
194
195   if(avcodec_check_dimensions(NULL, hdr_width, hdr_height))
196       return -1;
197
198   chroma_height = ((hdr_height >> 2) + 3) & 0x7ffc;
199   chroma_width = ((hdr_width >> 2) + 3) & 0x7ffc;
200   offs1 = bytestream_get_le32(&buf_pos);
201   offs2 = bytestream_get_le32(&buf_pos);
202   offs3 = bytestream_get_le32(&buf_pos);
203   buf_pos += 4;
204   hdr_pos = buf_pos;
205   if(fflags3 == 0x80) return 4;
206
207   if(fflags1 & 0x200) {
208     s->cur_frame = s->iv_frame + 1;
209     s->ref_frame = s->iv_frame;
210   } else {
211     s->cur_frame = s->iv_frame;
212     s->ref_frame = s->iv_frame + 1;
213   }
214
215   buf_pos = buf + 16 + offs1;
216   offs = bytestream_get_le32(&buf_pos);
217
218   iv_Decode_Chunk(s, s->cur_frame->Ybuf, s->ref_frame->Ybuf, hdr_width,
219     hdr_height, buf_pos + offs * 2, fflags2, hdr_pos, buf_pos,
220     FFMIN(hdr_width, 160));
221
222   if (!(s->avctx->flags & CODEC_FLAG_GRAY))
223   {
224
225   buf_pos = buf + 16 + offs2;
226   offs = bytestream_get_le32(&buf_pos);
227
228   iv_Decode_Chunk(s, s->cur_frame->Vbuf, s->ref_frame->Vbuf, chroma_width,
229     chroma_height, buf_pos + offs * 2, fflags2, hdr_pos, buf_pos,
230     FFMIN(chroma_width, 40));
231
232   buf_pos = buf + 16 + offs3;
233   offs = bytestream_get_le32(&buf_pos);
234
235   iv_Decode_Chunk(s, s->cur_frame->Ubuf, s->ref_frame->Ubuf, chroma_width,
236     chroma_height, buf_pos + offs * 2, fflags2, hdr_pos, buf_pos,
237     FFMIN(chroma_width, 40));
238
239   }
240
241   return 8;
242 }
243
244 typedef struct {
245   long xpos;
246   long ypos;
247   long width;
248   long height;
249   long split_flag;
250   long split_direction;
251   long usl7;
252 } ustr_t;
253
254 /* ---------------------------------------------------------------------- */
255
256 #define LV1_CHECK(buf1,rle_v3,lv1,lp2)  \
257   if((lv1 & 0x80) != 0) {   \
258     if(rle_v3 != 0)         \
259       rle_v3 = 0;           \
260     else {                  \
261       rle_v3 = 1;           \
262       buf1 -= 2;            \
263     }                       \
264   }                         \
265   lp2 = 4;
266
267
268 #define RLE_V3_CHECK(buf1,rle_v1,rle_v2,rle_v3)  \
269   if(rle_v3 == 0) {         \
270     rle_v2 = *buf1;         \
271     rle_v1 = 1;             \
272     if(rle_v2 > 32) {       \
273       rle_v2 -= 32;         \
274       rle_v1 = 0;           \
275     }                       \
276     rle_v3 = 1;             \
277   }                         \
278   buf1--;
279
280
281 #define LP2_CHECK(buf1,rle_v3,lp2)  \
282   if(lp2 == 0 && rle_v3 != 0)     \
283     rle_v3 = 0;           \
284   else {                  \
285     buf1--;               \
286     rle_v3 = 1;           \
287   }
288
289
290 #define RLE_V2_CHECK(buf1,rle_v2, rle_v3,lp2) \
291   rle_v2--;             \
292   if(rle_v2 == 0) {     \
293     rle_v3 = 0;         \
294     buf1 += 2;          \
295   }                     \
296   lp2 = 4;
297
298 static void iv_Decode_Chunk(Indeo3DecodeContext *s,
299   uint8_t *cur, uint8_t *ref, int width, int height,
300   const uint8_t *buf1, long fflags2, const uint8_t *hdr,
301   const uint8_t *buf2, int min_width_160)
302 {
303   uint8_t bit_buf;
304   unsigned long bit_pos, lv, lv1, lv2;
305   long *width_tbl, width_tbl_arr[10];
306   const signed char *ref_vectors;
307   uint8_t *cur_frm_pos, *ref_frm_pos, *cp, *cp2;
308   uint32_t *cur_lp, *ref_lp;
309   const uint32_t *correction_lp[2], *correctionloworder_lp[2], *correctionhighorder_lp[2];
310   uint8_t *correction_type_sp[2];
311   ustr_t strip_tbl[20], *strip;
312   int i, j, k, lp1, lp2, flag1, cmd, blks_width, blks_height, region_160_width,
313     rle_v1, rle_v2, rle_v3;
314   unsigned short res;
315
316   bit_buf = 0;
317   ref_vectors = NULL;
318
319   width_tbl = width_tbl_arr + 1;
320   i = (width < 0 ? width + 3 : width)/4;
321   for(j = -1; j < 8; j++)
322     width_tbl[j] = i * j;
323
324   strip = strip_tbl;
325
326   for(region_160_width = 0; region_160_width < (width - min_width_160); region_160_width += min_width_160);
327
328   strip->ypos = strip->xpos = 0;
329   for(strip->width = min_width_160; width > strip->width; strip->width *= 2);
330   strip->height = height;
331   strip->split_direction = 0;
332   strip->split_flag = 0;
333   strip->usl7 = 0;
334
335   bit_pos = 0;
336
337   rle_v1 = rle_v2 = rle_v3 = 0;
338
339   while(strip >= strip_tbl) {
340     if(bit_pos <= 0) {
341       bit_pos = 8;
342       bit_buf = *buf1++;
343     }
344
345     bit_pos -= 2;
346     cmd = (bit_buf >> bit_pos) & 0x03;
347
348     if(cmd == 0) {
349       strip++;
350       memcpy(strip, strip-1, sizeof(ustr_t));
351       strip->split_flag = 1;
352       strip->split_direction = 0;
353       strip->height = (strip->height > 8 ? ((strip->height+8)>>4)<<3 : 4);
354       continue;
355     } else if(cmd == 1) {
356       strip++;
357       memcpy(strip, strip-1, sizeof(ustr_t));
358       strip->split_flag = 1;
359       strip->split_direction = 1;
360       strip->width = (strip->width > 8 ? ((strip->width+8)>>4)<<3 : 4);
361       continue;
362     } else if(cmd == 2) {
363       if(strip->usl7 == 0) {
364         strip->usl7 = 1;
365         ref_vectors = NULL;
366         continue;
367       }
368     } else if(cmd == 3) {
369       if(strip->usl7 == 0) {
370         strip->usl7 = 1;
371         ref_vectors = (const signed char*)buf2 + (*buf1 * 2);
372         buf1++;
373         continue;
374       }
375     }
376
377     cur_frm_pos = cur + width * strip->ypos + strip->xpos;
378
379     if((blks_width = strip->width) < 0)
380       blks_width += 3;
381     blks_width >>= 2;
382     blks_height = strip->height;
383
384     if(ref_vectors != NULL) {
385       ref_frm_pos = ref + (ref_vectors[0] + strip->ypos) * width +
386         ref_vectors[1] + strip->xpos;
387     } else
388       ref_frm_pos = cur_frm_pos - width_tbl[4];
389
390     if(cmd == 2) {
391       if(bit_pos <= 0) {
392         bit_pos = 8;
393         bit_buf = *buf1++;
394       }
395
396       bit_pos -= 2;
397       cmd = (bit_buf >> bit_pos) & 0x03;
398
399       if(cmd == 0 || ref_vectors != NULL) {
400         for(lp1 = 0; lp1 < blks_width; lp1++) {
401           for(i = 0, j = 0; i < blks_height; i++, j += width_tbl[1])
402             ((uint32_t *)cur_frm_pos)[j] = ((uint32_t *)ref_frm_pos)[j];
403           cur_frm_pos += 4;
404           ref_frm_pos += 4;
405         }
406       } else if(cmd != 1)
407         return;
408     } else {
409       k = *buf1 >> 4;
410       j = *buf1 & 0x0f;
411       buf1++;
412       lv = j + fflags2;
413
414       if((lv - 8) <= 7 && (k == 0 || k == 3 || k == 10)) {
415         cp2 = s->ModPred + ((lv - 8) << 7);
416         cp = ref_frm_pos;
417         for(i = 0; i < blks_width << 2; i++) {
418             int v = *cp >> 1;
419             *(cp++) = cp2[v];
420         }
421       }
422
423       if(k == 1 || k == 4) {
424         lv = (hdr[j] & 0xf) + fflags2;
425         correction_type_sp[0] = s->corrector_type + (lv << 8);
426         correction_lp[0] = correction + (lv << 8);
427         lv = (hdr[j] >> 4) + fflags2;
428         correction_lp[1] = correction + (lv << 8);
429         correction_type_sp[1] = s->corrector_type + (lv << 8);
430       } else {
431         correctionloworder_lp[0] = correctionloworder_lp[1] = correctionloworder + (lv << 8);
432         correctionhighorder_lp[0] = correctionhighorder_lp[1] = correctionhighorder + (lv << 8);
433         correction_type_sp[0] = correction_type_sp[1] = s->corrector_type + (lv << 8);
434         correction_lp[0] = correction_lp[1] = correction + (lv << 8);
435       }
436
437       switch(k) {
438         case 1:
439         case 0:                    /********** CASE 0 **********/
440           for( ; blks_height > 0; blks_height -= 4) {
441             for(lp1 = 0; lp1 < blks_width; lp1++) {
442               for(lp2 = 0; lp2 < 4; ) {
443                 k = *buf1++;
444                 cur_lp = ((uint32_t *)cur_frm_pos) + width_tbl[lp2];
445                 ref_lp = ((uint32_t *)ref_frm_pos) + width_tbl[lp2];
446
447                 switch(correction_type_sp[0][k]) {
448                   case 0:
449                     *cur_lp = le2me_32(((le2me_32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
450                     lp2++;
451                     break;
452                   case 1:
453                     res = ((le2me_16(((unsigned short *)(ref_lp))[0]) >> 1) + correction_lp[lp2 & 0x01][*buf1]) << 1;
454                     ((unsigned short *)cur_lp)[0] = le2me_16(res);
455                     res = ((le2me_16(((unsigned short *)(ref_lp))[1]) >> 1) + correction_lp[lp2 & 0x01][k]) << 1;
456                     ((unsigned short *)cur_lp)[1] = le2me_16(res);
457                     buf1++;
458                     lp2++;
459                     break;
460                   case 2:
461                     if(lp2 == 0) {
462                       for(i = 0, j = 0; i < 2; i++, j += width_tbl[1])
463                         cur_lp[j] = ref_lp[j];
464                       lp2 += 2;
465                     }
466                     break;
467                   case 3:
468                     if(lp2 < 2) {
469                       for(i = 0, j = 0; i < (3 - lp2); i++, j += width_tbl[1])
470                         cur_lp[j] = ref_lp[j];
471                       lp2 = 3;
472                     }
473                     break;
474                   case 8:
475                     if(lp2 == 0) {
476                       RLE_V3_CHECK(buf1,rle_v1,rle_v2,rle_v3)
477
478                       if(rle_v1 == 1 || ref_vectors != NULL) {
479                         for(i = 0, j = 0; i < 4; i++, j += width_tbl[1])
480                           cur_lp[j] = ref_lp[j];
481                       }
482
483                       RLE_V2_CHECK(buf1,rle_v2, rle_v3,lp2)
484                       break;
485                     } else {
486                       rle_v1 = 1;
487                       rle_v2 = *buf1 - 1;
488                     }
489                   case 5:
490                       LP2_CHECK(buf1,rle_v3,lp2)
491                   case 4:
492                     for(i = 0, j = 0; i < (4 - lp2); i++, j += width_tbl[1])
493                       cur_lp[j] = ref_lp[j];
494                     lp2 = 4;
495                     break;
496
497                   case 7:
498                     if(rle_v3 != 0)
499                       rle_v3 = 0;
500                     else {
501                       buf1--;
502                       rle_v3 = 1;
503                     }
504                   case 6:
505                     if(ref_vectors != NULL) {
506                       for(i = 0, j = 0; i < 4; i++, j += width_tbl[1])
507                         cur_lp[j] = ref_lp[j];
508                     }
509                     lp2 = 4;
510                     break;
511
512                   case 9:
513                     lv1 = *buf1++;
514                     lv = (lv1 & 0x7F) << 1;
515                     lv += (lv << 8);
516                     lv += (lv << 16);
517                     for(i = 0, j = 0; i < 4; i++, j += width_tbl[1])
518                       cur_lp[j] = lv;
519
520                     LV1_CHECK(buf1,rle_v3,lv1,lp2)
521                     break;
522                   default:
523                     return;
524                 }
525               }
526
527               cur_frm_pos += 4;
528               ref_frm_pos += 4;
529             }
530
531             cur_frm_pos += ((width - blks_width) * 4);
532             ref_frm_pos += ((width - blks_width) * 4);
533           }
534           break;
535
536         case 4:
537         case 3:                    /********** CASE 3 **********/
538           if(ref_vectors != NULL)
539             return;
540           flag1 = 1;
541
542           for( ; blks_height > 0; blks_height -= 8) {
543             for(lp1 = 0; lp1 < blks_width; lp1++) {
544               for(lp2 = 0; lp2 < 4; ) {
545                 k = *buf1++;
546
547                 cur_lp = ((uint32_t *)cur_frm_pos) + width_tbl[lp2 * 2];
548                 ref_lp = ((uint32_t *)cur_frm_pos) + width_tbl[(lp2 * 2) - 1];
549
550                 switch(correction_type_sp[lp2 & 0x01][k]) {
551                   case 0:
552                     cur_lp[width_tbl[1]] = le2me_32(((le2me_32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
553                     if(lp2 > 0 || flag1 == 0 || strip->ypos != 0)
554                       cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
555                     else
556                       cur_lp[0] = le2me_32(((le2me_32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
557                     lp2++;
558                     break;
559
560                   case 1:
561                     res = ((le2me_16(((unsigned short *)ref_lp)[0]) >> 1) + correction_lp[lp2 & 0x01][*buf1]) << 1;
562                     ((unsigned short *)cur_lp)[width_tbl[2]] = le2me_16(res);
563                     res = ((le2me_16(((unsigned short *)ref_lp)[1]) >> 1) + correction_lp[lp2 & 0x01][k]) << 1;
564                     ((unsigned short *)cur_lp)[width_tbl[2]+1] = le2me_16(res);
565
566                     if(lp2 > 0 || flag1 == 0 || strip->ypos != 0)
567                       cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
568                     else
569                       cur_lp[0] = cur_lp[width_tbl[1]];
570                     buf1++;
571                     lp2++;
572                     break;
573
574                   case 2:
575                     if(lp2 == 0) {
576                       for(i = 0, j = 0; i < 4; i++, j += width_tbl[1])
577                         cur_lp[j] = *ref_lp;
578                       lp2 += 2;
579                     }
580                     break;
581
582                   case 3:
583                     if(lp2 < 2) {
584                       for(i = 0, j = 0; i < 6 - (lp2 * 2); i++, j += width_tbl[1])
585                         cur_lp[j] = *ref_lp;
586                       lp2 = 3;
587                     }
588                     break;
589
590                   case 6:
591                     lp2 = 4;
592                     break;
593
594                   case 7:
595                     if(rle_v3 != 0)
596                       rle_v3 = 0;
597                     else {
598                       buf1--;
599                       rle_v3 = 1;
600                     }
601                     lp2 = 4;
602                     break;
603
604                   case 8:
605                     if(lp2 == 0) {
606                       RLE_V3_CHECK(buf1,rle_v1,rle_v2,rle_v3)
607
608                       if(rle_v1 == 1) {
609                         for(i = 0, j = 0; i < 8; i++, j += width_tbl[1])
610                           cur_lp[j] = ref_lp[j];
611                       }
612
613                       RLE_V2_CHECK(buf1,rle_v2, rle_v3,lp2)
614                       break;
615                     } else {
616                       rle_v2 = (*buf1) - 1;
617                       rle_v1 = 1;
618                     }
619                   case 5:
620                       LP2_CHECK(buf1,rle_v3,lp2)
621                   case 4:
622                     for(i = 0, j = 0; i < 8 - (lp2 * 2); i++, j += width_tbl[1])
623                       cur_lp[j] = *ref_lp;
624                     lp2 = 4;
625                     break;
626
627                   case 9:
628                     av_log(s->avctx, AV_LOG_ERROR, "UNTESTED.\n");
629                     lv1 = *buf1++;
630                     lv = (lv1 & 0x7F) << 1;
631                     lv += (lv << 8);
632                     lv += (lv << 16);
633
634                     for(i = 0, j = 0; i < 4; i++, j += width_tbl[1])
635                       cur_lp[j] = lv;
636
637                     LV1_CHECK(buf1,rle_v3,lv1,lp2)
638                     break;
639
640                   default:
641                     return;
642                 }
643               }
644
645               cur_frm_pos += 4;
646             }
647
648             cur_frm_pos += (((width * 2) - blks_width) * 4);
649             flag1 = 0;
650           }
651           break;
652
653         case 10:                    /********** CASE 10 **********/
654           if(ref_vectors == NULL) {
655             flag1 = 1;
656
657             for( ; blks_height > 0; blks_height -= 8) {
658               for(lp1 = 0; lp1 < blks_width; lp1 += 2) {
659                 for(lp2 = 0; lp2 < 4; ) {
660                   k = *buf1++;
661                   cur_lp = ((uint32_t *)cur_frm_pos) + width_tbl[lp2 * 2];
662                   ref_lp = ((uint32_t *)cur_frm_pos) + width_tbl[(lp2 * 2) - 1];
663                   lv1 = ref_lp[0];
664                   lv2 = ref_lp[1];
665                   if(lp2 == 0 && flag1 != 0) {
666 #ifdef WORDS_BIGENDIAN
667                     lv1 = lv1 & 0xFF00FF00;
668                     lv1 = (lv1 >> 8) | lv1;
669                     lv2 = lv2 & 0xFF00FF00;
670                     lv2 = (lv2 >> 8) | lv2;
671 #else
672                     lv1 = lv1 & 0x00FF00FF;
673                     lv1 = (lv1 << 8) | lv1;
674                     lv2 = lv2 & 0x00FF00FF;
675                     lv2 = (lv2 << 8) | lv2;
676 #endif
677                   }
678
679                   switch(correction_type_sp[lp2 & 0x01][k]) {
680                     case 0:
681                       cur_lp[width_tbl[1]] = le2me_32(((le2me_32(lv1) >> 1) + correctionloworder_lp[lp2 & 0x01][k]) << 1);
682                       cur_lp[width_tbl[1]+1] = le2me_32(((le2me_32(lv2) >> 1) + correctionhighorder_lp[lp2 & 0x01][k]) << 1);
683                       if(lp2 > 0 || strip->ypos != 0 || flag1 == 0) {
684                         cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
685                         cur_lp[1] = ((cur_lp[-width_tbl[1]+1] >> 1) + (cur_lp[width_tbl[1]+1] >> 1)) & 0xFEFEFEFE;
686                       } else {
687                         cur_lp[0] = cur_lp[width_tbl[1]];
688                         cur_lp[1] = cur_lp[width_tbl[1]+1];
689                       }
690                       lp2++;
691                       break;
692
693                     case 1:
694                       cur_lp[width_tbl[1]] = le2me_32(((le2me_32(lv1) >> 1) + correctionloworder_lp[lp2 & 0x01][*buf1]) << 1);
695                       cur_lp[width_tbl[1]+1] = le2me_32(((le2me_32(lv2) >> 1) + correctionloworder_lp[lp2 & 0x01][k]) << 1);
696                       if(lp2 > 0 || strip->ypos != 0 || flag1 == 0) {
697                         cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
698                         cur_lp[1] = ((cur_lp[-width_tbl[1]+1] >> 1) + (cur_lp[width_tbl[1]+1] >> 1)) & 0xFEFEFEFE;
699                       } else {
700                         cur_lp[0] = cur_lp[width_tbl[1]];
701                         cur_lp[1] = cur_lp[width_tbl[1]+1];
702                       }
703                       buf1++;
704                       lp2++;
705                       break;
706
707                     case 2:
708                       if(lp2 == 0) {
709                         if(flag1 != 0) {
710                           for(i = 0, j = width_tbl[1]; i < 3; i++, j += width_tbl[1]) {
711                             cur_lp[j] = lv1;
712                             cur_lp[j+1] = lv2;
713                           }
714                           cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
715                           cur_lp[1] = ((cur_lp[-width_tbl[1]+1] >> 1) + (cur_lp[width_tbl[1]+1] >> 1)) & 0xFEFEFEFE;
716                         } else {
717                           for(i = 0, j = 0; i < 4; i++, j += width_tbl[1]) {
718                             cur_lp[j] = lv1;
719                             cur_lp[j+1] = lv2;
720                           }
721                         }
722                         lp2 += 2;
723                       }
724                       break;
725
726                     case 3:
727                       if(lp2 < 2) {
728                         if(lp2 == 0 && flag1 != 0) {
729                           for(i = 0, j = width_tbl[1]; i < 5; i++, j += width_tbl[1]) {
730                             cur_lp[j] = lv1;
731                             cur_lp[j+1] = lv2;
732                           }
733                           cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
734                           cur_lp[1] = ((cur_lp[-width_tbl[1]+1] >> 1) + (cur_lp[width_tbl[1]+1] >> 1)) & 0xFEFEFEFE;
735                         } else {
736                           for(i = 0, j = 0; i < 6 - (lp2 * 2); i++, j += width_tbl[1]) {
737                             cur_lp[j] = lv1;
738                             cur_lp[j+1] = lv2;
739                           }
740                         }
741                         lp2 = 3;
742                       }
743                       break;
744
745                     case 8:
746                       if(lp2 == 0) {
747                         RLE_V3_CHECK(buf1,rle_v1,rle_v2,rle_v3)
748                         if(rle_v1 == 1) {
749                           if(flag1 != 0) {
750                             for(i = 0, j = width_tbl[1]; i < 7; i++, j += width_tbl[1]) {
751                               cur_lp[j] = lv1;
752                               cur_lp[j+1] = lv2;
753                             }
754                             cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
755                             cur_lp[1] = ((cur_lp[-width_tbl[1]+1] >> 1) + (cur_lp[width_tbl[1]+1] >> 1)) & 0xFEFEFEFE;
756                           } else {
757                             for(i = 0, j = 0; i < 8; i++, j += width_tbl[1]) {
758                               cur_lp[j] = lv1;
759                               cur_lp[j+1] = lv2;
760                             }
761                           }
762                         }
763                         RLE_V2_CHECK(buf1,rle_v2, rle_v3,lp2)
764                         break;
765                       } else {
766                         rle_v1 = 1;
767                         rle_v2 = (*buf1) - 1;
768                       }
769                     case 5:
770                         LP2_CHECK(buf1,rle_v3,lp2)
771                     case 4:
772                       if(lp2 == 0 && flag1 != 0) {
773                         for(i = 0, j = width_tbl[1]; i < 7; i++, j += width_tbl[1]) {
774                           cur_lp[j] = lv1;
775                           cur_lp[j+1] = lv2;
776                         }
777                         cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
778                         cur_lp[1] = ((cur_lp[-width_tbl[1]+1] >> 1) + (cur_lp[width_tbl[1]+1] >> 1)) & 0xFEFEFEFE;
779                       } else {
780                         for(i = 0, j = 0; i < 8 - (lp2 * 2); i++, j += width_tbl[1]) {
781                           cur_lp[j] = lv1;
782                           cur_lp[j+1] = lv2;
783                         }
784                       }
785                       lp2 = 4;
786                       break;
787
788                     case 6:
789                       lp2 = 4;
790                       break;
791
792                     case 7:
793                       if(lp2 == 0) {
794                         if(rle_v3 != 0)
795                           rle_v3 = 0;
796                         else {
797                           buf1--;
798                           rle_v3 = 1;
799                         }
800                         lp2 = 4;
801                       }
802                       break;
803
804                     case 9:
805                       av_log(s->avctx, AV_LOG_ERROR, "UNTESTED.\n");
806                       lv1 = *buf1;
807                       lv = (lv1 & 0x7F) << 1;
808                       lv += (lv << 8);
809                       lv += (lv << 16);
810                       for(i = 0, j = 0; i < 8; i++, j += width_tbl[1])
811                         cur_lp[j] = lv;
812                       LV1_CHECK(buf1,rle_v3,lv1,lp2)
813                       break;
814
815                     default:
816                       return;
817                   }
818                 }
819
820                 cur_frm_pos += 8;
821               }
822
823               cur_frm_pos += (((width * 2) - blks_width) * 4);
824               flag1 = 0;
825             }
826           } else {
827             for( ; blks_height > 0; blks_height -= 8) {
828               for(lp1 = 0; lp1 < blks_width; lp1 += 2) {
829                 for(lp2 = 0; lp2 < 4; ) {
830                   k = *buf1++;
831                   cur_lp = ((uint32_t *)cur_frm_pos) + width_tbl[lp2 * 2];
832                   ref_lp = ((uint32_t *)ref_frm_pos) + width_tbl[lp2 * 2];
833
834                   switch(correction_type_sp[lp2 & 0x01][k]) {
835                     case 0:
836                       lv1 = correctionloworder_lp[lp2 & 0x01][k];
837                       lv2 = correctionhighorder_lp[lp2 & 0x01][k];
838                       cur_lp[0] = le2me_32(((le2me_32(ref_lp[0]) >> 1) + lv1) << 1);
839                       cur_lp[1] = le2me_32(((le2me_32(ref_lp[1]) >> 1) + lv2) << 1);
840                       cur_lp[width_tbl[1]] = le2me_32(((le2me_32(ref_lp[width_tbl[1]]) >> 1) + lv1) << 1);
841                       cur_lp[width_tbl[1]+1] = le2me_32(((le2me_32(ref_lp[width_tbl[1]+1]) >> 1) + lv2) << 1);
842                       lp2++;
843                       break;
844
845                     case 1:
846                       lv1 = correctionloworder_lp[lp2 & 0x01][*buf1++];
847                       lv2 = correctionloworder_lp[lp2 & 0x01][k];
848                       cur_lp[0] = le2me_32(((le2me_32(ref_lp[0]) >> 1) + lv1) << 1);
849                       cur_lp[1] = le2me_32(((le2me_32(ref_lp[1]) >> 1) + lv2) << 1);
850                       cur_lp[width_tbl[1]] = le2me_32(((le2me_32(ref_lp[width_tbl[1]]) >> 1) + lv1) << 1);
851                       cur_lp[width_tbl[1]+1] = le2me_32(((le2me_32(ref_lp[width_tbl[1]+1]) >> 1) + lv2) << 1);
852                       lp2++;
853                       break;
854
855                     case 2:
856                       if(lp2 == 0) {
857                         for(i = 0, j = 0; i < 4; i++, j += width_tbl[1]) {
858                           cur_lp[j] = ref_lp[j];
859                           cur_lp[j+1] = ref_lp[j+1];
860                         }
861                         lp2 += 2;
862                       }
863                       break;
864
865                     case 3:
866                       if(lp2 < 2) {
867                         for(i = 0, j = 0; i < 6 - (lp2 * 2); i++, j += width_tbl[1]) {
868                           cur_lp[j] = ref_lp[j];
869                           cur_lp[j+1] = ref_lp[j+1];
870                         }
871                         lp2 = 3;
872                       }
873                       break;
874
875                     case 8:
876                       if(lp2 == 0) {
877                         RLE_V3_CHECK(buf1,rle_v1,rle_v2,rle_v3)
878                         for(i = 0, j = 0; i < 8; i++, j += width_tbl[1]) {
879                           ((uint32_t *)cur_frm_pos)[j] = ((uint32_t *)ref_frm_pos)[j];
880                           ((uint32_t *)cur_frm_pos)[j+1] = ((uint32_t *)ref_frm_pos)[j+1];
881                         }
882                         RLE_V2_CHECK(buf1,rle_v2, rle_v3,lp2)
883                         break;
884                       } else {
885                         rle_v1 = 1;
886                         rle_v2 = (*buf1) - 1;
887                       }
888                     case 5:
889                     case 7:
890                         LP2_CHECK(buf1,rle_v3,lp2)
891                     case 6:
892                     case 4:
893                       for(i = 0, j = 0; i < 8 - (lp2 * 2); i++, j += width_tbl[1]) {
894                         cur_lp[j] = ref_lp[j];
895                         cur_lp[j+1] = ref_lp[j+1];
896                       }
897                       lp2 = 4;
898                       break;
899
900                     case 9:
901                       av_log(s->avctx, AV_LOG_ERROR, "UNTESTED.\n");
902                       lv1 = *buf1;
903                       lv = (lv1 & 0x7F) << 1;
904                       lv += (lv << 8);
905                       lv += (lv << 16);
906                       for(i = 0, j = 0; i < 8; i++, j += width_tbl[1])
907                         ((uint32_t *)cur_frm_pos)[j] = ((uint32_t *)cur_frm_pos)[j+1] = lv;
908                       LV1_CHECK(buf1,rle_v3,lv1,lp2)
909                       break;
910
911                     default:
912                       return;
913                   }
914                 }
915
916                 cur_frm_pos += 8;
917                 ref_frm_pos += 8;
918               }
919
920               cur_frm_pos += (((width * 2) - blks_width) * 4);
921               ref_frm_pos += (((width * 2) - blks_width) * 4);
922             }
923           }
924           break;
925
926         case 11:                    /********** CASE 11 **********/
927           if(ref_vectors == NULL)
928             return;
929
930           for( ; blks_height > 0; blks_height -= 8) {
931             for(lp1 = 0; lp1 < blks_width; lp1++) {
932               for(lp2 = 0; lp2 < 4; ) {
933                 k = *buf1++;
934                 cur_lp = ((uint32_t *)cur_frm_pos) + width_tbl[lp2 * 2];
935                 ref_lp = ((uint32_t *)ref_frm_pos) + width_tbl[lp2 * 2];
936
937                 switch(correction_type_sp[lp2 & 0x01][k]) {
938                   case 0:
939                     cur_lp[0] = le2me_32(((le2me_32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
940                     cur_lp[width_tbl[1]] = le2me_32(((le2me_32(ref_lp[width_tbl[1]]) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
941                     lp2++;
942                     break;
943
944                   case 1:
945                     lv1 = (unsigned short)(correction_lp[lp2 & 0x01][*buf1++]);
946                     lv2 = (unsigned short)(correction_lp[lp2 & 0x01][k]);
947                     res = (unsigned short)(((le2me_16(((unsigned short *)ref_lp)[0]) >> 1) + lv1) << 1);
948                     ((unsigned short *)cur_lp)[0] = le2me_16(res);
949                     res = (unsigned short)(((le2me_16(((unsigned short *)ref_lp)[1]) >> 1) + lv2) << 1);
950                     ((unsigned short *)cur_lp)[1] = le2me_16(res);
951                     res = (unsigned short)(((le2me_16(((unsigned short *)ref_lp)[width_tbl[2]]) >> 1) + lv1) << 1);
952                     ((unsigned short *)cur_lp)[width_tbl[2]] = le2me_16(res);
953                     res = (unsigned short)(((le2me_16(((unsigned short *)ref_lp)[width_tbl[2]+1]) >> 1) + lv2) << 1);
954                     ((unsigned short *)cur_lp)[width_tbl[2]+1] = le2me_16(res);
955                     lp2++;
956                     break;
957
958                   case 2:
959                     if(lp2 == 0) {
960                       for(i = 0, j = 0; i < 4; i++, j += width_tbl[1])
961                         cur_lp[j] = ref_lp[j];
962                       lp2 += 2;
963                     }
964                     break;
965
966                   case 3:
967                     if(lp2 < 2) {
968                       for(i = 0, j = 0; i < 6 - (lp2 * 2); i++, j += width_tbl[1])
969                         cur_lp[j] = ref_lp[j];
970                       lp2 = 3;
971                     }
972                     break;
973
974                   case 8:
975                     if(lp2 == 0) {
976                       RLE_V3_CHECK(buf1,rle_v1,rle_v2,rle_v3)
977
978                       for(i = 0, j = 0; i < 8; i++, j += width_tbl[1])
979                         cur_lp[j] = ref_lp[j];
980
981                       RLE_V2_CHECK(buf1,rle_v2, rle_v3,lp2)
982                       break;
983                     } else {
984                       rle_v1 = 1;
985                       rle_v2 = (*buf1) - 1;
986                     }
987                   case 5:
988                   case 7:
989                       LP2_CHECK(buf1,rle_v3,lp2)
990                   case 4:
991                   case 6:
992                     for(i = 0, j = 0; i < 8 - (lp2 * 2); i++, j += width_tbl[1])
993                       cur_lp[j] = ref_lp[j];
994                     lp2 = 4;
995                     break;
996
997                 case 9:
998                   av_log(s->avctx, AV_LOG_ERROR, "UNTESTED.\n");
999                   lv1 = *buf1++;
1000                   lv = (lv1 & 0x7F) << 1;
1001                   lv += (lv << 8);
1002                   lv += (lv << 16);
1003                   for(i = 0, j = 0; i < 4; i++, j += width_tbl[1])
1004                     cur_lp[j] = lv;
1005                   LV1_CHECK(buf1,rle_v3,lv1,lp2)
1006                   break;
1007
1008                   default:
1009                     return;
1010                 }
1011               }
1012
1013               cur_frm_pos += 4;
1014               ref_frm_pos += 4;
1015             }
1016
1017             cur_frm_pos += (((width * 2) - blks_width) * 4);
1018             ref_frm_pos += (((width * 2) - blks_width) * 4);
1019           }
1020           break;
1021
1022         default:
1023           return;
1024       }
1025     }
1026
1027     if(strip < strip_tbl)
1028       return;
1029
1030     for( ; strip >= strip_tbl; strip--) {
1031       if(strip->split_flag != 0) {
1032         strip->split_flag = 0;
1033         strip->usl7 = (strip-1)->usl7;
1034
1035         if(strip->split_direction) {
1036           strip->xpos += strip->width;
1037           strip->width = (strip-1)->width - strip->width;
1038           if(region_160_width <= strip->xpos && width < strip->width + strip->xpos)
1039             strip->width = width - strip->xpos;
1040         } else {
1041           strip->ypos += strip->height;
1042           strip->height = (strip-1)->height - strip->height;
1043         }
1044         break;
1045       }
1046     }
1047   }
1048 }
1049
1050 static av_cold int indeo3_decode_init(AVCodecContext *avctx)
1051 {
1052     Indeo3DecodeContext *s = avctx->priv_data;
1053
1054     s->avctx = avctx;
1055     s->width = avctx->width;
1056     s->height = avctx->height;
1057     avctx->pix_fmt = PIX_FMT_YUV410P;
1058
1059     build_modpred(s);
1060     iv_alloc_frames(s);
1061
1062     return 0;
1063 }
1064
1065 static int indeo3_decode_frame(AVCodecContext *avctx,
1066                                void *data, int *data_size,
1067                                const uint8_t *buf, int buf_size)
1068 {
1069     Indeo3DecodeContext *s=avctx->priv_data;
1070     uint8_t *src, *dest;
1071     int y;
1072
1073     iv_decode_frame(s, buf, buf_size);
1074
1075     if(s->frame.data[0])
1076         avctx->release_buffer(avctx, &s->frame);
1077
1078     s->frame.reference = 0;
1079     if(avctx->get_buffer(avctx, &s->frame) < 0) {
1080         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1081         return -1;
1082     }
1083
1084     src = s->cur_frame->Ybuf;
1085     dest = s->frame.data[0];
1086     for (y = 0; y < s->height; y++) {
1087       memcpy(dest, src, s->cur_frame->y_w);
1088       src += s->cur_frame->y_w;
1089       dest += s->frame.linesize[0];
1090     }
1091
1092     if (!(s->avctx->flags & CODEC_FLAG_GRAY))
1093     {
1094     src = s->cur_frame->Ubuf;
1095     dest = s->frame.data[1];
1096     for (y = 0; y < s->height / 4; y++) {
1097       memcpy(dest, src, s->cur_frame->uv_w);
1098       src += s->cur_frame->uv_w;
1099       dest += s->frame.linesize[1];
1100     }
1101
1102     src = s->cur_frame->Vbuf;
1103     dest = s->frame.data[2];
1104     for (y = 0; y < s->height / 4; y++) {
1105       memcpy(dest, src, s->cur_frame->uv_w);
1106       src += s->cur_frame->uv_w;
1107       dest += s->frame.linesize[2];
1108     }
1109     }
1110
1111     *data_size=sizeof(AVFrame);
1112     *(AVFrame*)data= s->frame;
1113
1114     return buf_size;
1115 }
1116
1117 static av_cold int indeo3_decode_end(AVCodecContext *avctx)
1118 {
1119     Indeo3DecodeContext *s = avctx->priv_data;
1120
1121     iv_free_func(s);
1122
1123     return 0;
1124 }
1125
1126 AVCodec indeo3_decoder = {
1127     "indeo3",
1128     CODEC_TYPE_VIDEO,
1129     CODEC_ID_INDEO3,
1130     sizeof(Indeo3DecodeContext),
1131     indeo3_decode_init,
1132     NULL,
1133     indeo3_decode_end,
1134     indeo3_decode_frame,
1135     0,
1136     NULL,
1137     .long_name = NULL_IF_CONFIG_SMALL("Intel Indeo 3"),
1138 };