← Back to branch summary

~ubuntu-branches/ubuntu/edgy/gstreamer0.10-ffmpeg/edgy

« back to all changes in this revision

Viewing changes to gst-libs/ext/ffmpeg/libavcodec/indeo3.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2006-04-01 16:13:43 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20060401161343-08cyx5z9c530gtrd
Tags: 0.10.1-0ubuntu1
* New upstream release:
  Features since 0.10.0:
    + Parallel installability with 0.8.x series
    + Threadsafe design and API
    + ffvideoscale ported
    + ffdeinterlace ported
    + demuxer wrapper works pull-based
    + disabled mpeg2 video and mp3 audio autoplugging
    + fixes for Indeo3, PNG, smc, H264 HD, H263, FLV1, G2
  Bugs fixed since 0.10.0:
    + [ffdemux_mp3] ffmpeg mp3 decoder miss seeking
    + Reading mpeg-ts stream from standard input does not work
    + configure script doesn't accept --with-pkg-config-path ar...
    + Fails to build under powerpc
    + avcodec_open()/close() aren't thread-safe
    + [ffdec_cinepak] chef.avi causes gstreamer to hang in preroll
    + Indeo AVI files do not play with 0.10
    + [ffdec] Memory leak when joining pcache
    + MS Video 1 palettized AVI doesn't work
    + ffdeinterlace port to 0.10
    + [ffmpegenc] FFMpeg audio encoders do not set caps to buffers
    + gstreamer CVS doesn't work with ffmpeg codecs
    + Wrap the ffmpeg demuxers
    + [ffdec_h264] seeking in " IntoTheBlue_Cin_AVC.mp4 " crashes...
    + Too fast playback of h263p encoded file
    + FFmpeg video scale port to 0.10
    + segfault in ffmpeg enc
    + Memory leak in ffmpegenc
    + [CVE-2005-4048] avcodec_default_get_buffer heap overflow
* debian/patches/32_CVE-2005-4048_avcodec-default-get-buffer-heap-overflow.patch:
  - Dropped, this is upstream now

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/ffmpeg/libavcodec/indeo3.c
14
14
 *
15
15
 * You should have received a copy of the GNU Lesser General Public
16
16
 * License along with this library; if not, write to the Free Software
17
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
18
 */
19
19
 
20
20
#include <stdio.h>
61
61
 
62
62
static int corrector_type_2[8] = { 9, 7, 6, 8, 5, 4, 3, 2 };
63
63
 
64
 
static void build_modpred(Indeo3DecodeContext *s) 
 
64
static void build_modpred(Indeo3DecodeContext *s)
65
65
{
66
66
  int i, j;
67
67
 
70
70
  for (i=0; i < 128; ++i) {
71
71
    s->ModPred[i+0*128] = (i > 126) ? 254 : 2*((i + 1) - ((i + 1) % 2));
72
72
    s->ModPred[i+1*128] = (i == 7)  ?  20 : ((i == 119 || i == 120)
73
 
                                 ? 236 : 2*((i + 2) - ((i + 1) % 3)));
 
73
                                 ? 236 : 2*((i + 2) - ((i + 1) % 3)));
74
74
    s->ModPred[i+2*128] = (i > 125) ? 248 : 2*((i + 2) - ((i + 2) % 4));
75
 
    s->ModPred[i+3*128] =                        2*((i + 1) - ((i - 3) % 5));
 
75
    s->ModPred[i+3*128] =                        2*((i + 1) - ((i - 3) % 5));
76
76
    s->ModPred[i+4*128] = (i == 8)  ?  20 : 2*((i + 1) - ((i - 3) % 6));
77
 
    s->ModPred[i+5*128] =                        2*((i + 4) - ((i + 3) % 7));
 
77
    s->ModPred[i+5*128] =                        2*((i + 4) - ((i + 3) % 7));
78
78
    s->ModPred[i+6*128] = (i > 123) ? 240 : 2*((i + 4) - ((i + 4) % 8));
79
 
    s->ModPred[i+7*128] =                        2*((i + 5) - ((i + 4) % 9));
 
79
    s->ModPred[i+7*128] =                        2*((i + 5) - ((i + 4) % 9));
80
80
  }
81
81
 
82
82
  s->corrector_type = (unsigned short *) av_malloc (24 * 256 * sizeof(unsigned short));
84
84
  for (i=0; i < 24; ++i) {
85
85
    for (j=0; j < 256; ++j) {
86
86
      s->corrector_type[i*256+j] = (j < corrector_type_0[i])
87
 
                                ? 1 : ((j < 248 || (i == 16 && j == 248))
88
 
                                       ? 0 : corrector_type_2[j - 248]);
 
87
                                ? 1 : ((j < 248 || (i == 16 && j == 248))
 
88
                                       ? 0 : corrector_type_2[j - 248]);
89
89
    }
90
90
  }
91
91
}
92
92
 
93
 
static void iv_Decode_Chunk(Indeo3DecodeContext *s, unsigned char *cur, 
94
 
  unsigned char *ref, int width, int height, unsigned char *buf1, 
 
93
static void iv_Decode_Chunk(Indeo3DecodeContext *s, unsigned char *cur,
 
94
  unsigned char *ref, int width, int height, unsigned char *buf1,
95
95
  long fflags2, unsigned char *hdr,
96
96
  unsigned char *buf2, int min_width_160);
97
97
 
100
100
#endif
101
101
 
102
102
/* ---------------------------------------------------------------------- */
103
 
static void iv_alloc_frames(Indeo3DecodeContext *s) 
 
103
static void iv_alloc_frames(Indeo3DecodeContext *s)
104
104
{
105
105
  int luma_width, luma_height, luma_pixels, chroma_width, chroma_height,
106
106
      chroma_pixels, i;
109
109
  luma_width   = (s->width  + 3) & (~3);
110
110
  luma_height  = (s->height + 3) & (~3);
111
111
 
112
 
  s->iv_frame[0].y_w = s->iv_frame[0].y_h = 
 
112
  s->iv_frame[0].y_w = s->iv_frame[0].y_h =
113
113
    s->iv_frame[0].the_buf_size = 0;
114
 
  s->iv_frame[1].y_w = s->iv_frame[1].y_h = 
 
114
  s->iv_frame[1].y_w = s->iv_frame[1].y_h =
115
115
    s->iv_frame[1].the_buf_size = 0;
116
116
  s->iv_frame[1].the_buf = NULL;
117
117
 
120
120
  luma_pixels = luma_width * luma_height;
121
121
  chroma_pixels = chroma_width * chroma_height;
122
122
 
123
 
  bufsize = luma_pixels * 2 + luma_width * 3 + 
 
123
  bufsize = luma_pixels * 2 + luma_width * 3 +
124
124
    (chroma_pixels + chroma_width) * 4;
125
125
 
126
 
  if((s->iv_frame[0].the_buf = 
127
 
    (s->iv_frame[0].the_buf_size == 0 ? av_malloc(bufsize) : 
 
126
  if((s->iv_frame[0].the_buf =
 
127
    (s->iv_frame[0].the_buf_size == 0 ? av_malloc(bufsize) :
128
128
      av_realloc(s->iv_frame[0].the_buf, bufsize))) == NULL)
129
129
    return;
130
130
  s->iv_frame[0].y_w = s->iv_frame[1].y_w = luma_width;
146
146
  s->iv_frame[1].Vbuf = s->iv_frame[0].the_buf + i;
147
147
 
148
148
  for(i = 1; i <= luma_width; i++)
149
 
    s->iv_frame[0].Ybuf[-i] = s->iv_frame[1].Ybuf[-i] = 
 
149
    s->iv_frame[0].Ybuf[-i] = s->iv_frame[1].Ybuf[-i] =
150
150
      s->iv_frame[0].Ubuf[-i] = 0x80;
151
151
 
152
152
  for(i = 1; i <= chroma_width; i++) {
158
158
}
159
159
 
160
160
/* ---------------------------------------------------------------------- */
161
 
static void iv_free_func(Indeo3DecodeContext *s) 
 
161
static void iv_free_func(Indeo3DecodeContext *s)
162
162
{
163
163
  int i;
164
164
 
165
165
  for(i = 0 ; i < 2 ; i++) {
166
 
    if(s->iv_frame[i].the_buf != NULL) 
 
166
    if(s->iv_frame[i].the_buf != NULL)
167
167
      av_free(s->iv_frame[i].the_buf);
168
 
    s->iv_frame[i].Ybuf = s->iv_frame[i].Ubuf = 
 
168
    s->iv_frame[i].Ybuf = s->iv_frame[i].Ubuf =
169
169
      s->iv_frame[i].Vbuf = NULL;
170
170
    s->iv_frame[i].the_buf = NULL;
171
171
    s->iv_frame[i].the_buf_size = 0;
178
178
}
179
179
 
180
180
/* ---------------------------------------------------------------------- */
181
 
static unsigned long iv_decode_frame(Indeo3DecodeContext *s, 
182
 
                                     unsigned char *buf, int buf_size) 
 
181
static unsigned long iv_decode_frame(Indeo3DecodeContext *s,
 
182
                                     unsigned char *buf, int buf_size)
183
183
{
184
184
  unsigned int hdr_width, hdr_height,
185
185
    chroma_width, chroma_height;
198
198
  hdr_height = le2me_16(*(uint16_t *)buf_pos);
199
199
  buf_pos += 2;
200
200
  hdr_width = le2me_16(*(uint16_t *)buf_pos);
201
 
  
 
201
 
202
202
  if(avcodec_check_dimensions(NULL, hdr_width, hdr_height))
203
203
      return -1;
204
 
  
 
204
 
205
205
  buf_pos += 2;
206
206
  chroma_height = ((hdr_height >> 2) + 3) & 0x7ffc;
207
207
  chroma_width = ((hdr_width >> 2) + 3) & 0x7ffc;
226
226
  offs = le2me_32(*(uint32_t *)buf_pos);
227
227
  buf_pos += 4;
228
228
 
229
 
  iv_Decode_Chunk(s, s->cur_frame->Ybuf, s->ref_frame->Ybuf, hdr_width, 
230
 
    hdr_height, buf_pos + offs * 2, fflags2, hdr_pos, buf_pos, 
 
229
  iv_Decode_Chunk(s, s->cur_frame->Ybuf, s->ref_frame->Ybuf, hdr_width,
 
230
    hdr_height, buf_pos + offs * 2, fflags2, hdr_pos, buf_pos,
231
231
    min(hdr_width, 160));
232
232
 
233
233
  if (!(s->avctx->flags & CODEC_FLAG_GRAY))
237
237
  offs = le2me_32(*(uint32_t *)buf_pos);
238
238
  buf_pos += 4;
239
239
 
240
 
  iv_Decode_Chunk(s, s->cur_frame->Vbuf, s->ref_frame->Vbuf, chroma_width, 
241
 
    chroma_height, buf_pos + offs * 2, fflags2, hdr_pos, buf_pos, 
 
240
  iv_Decode_Chunk(s, s->cur_frame->Vbuf, s->ref_frame->Vbuf, chroma_width,
 
241
    chroma_height, buf_pos + offs * 2, fflags2, hdr_pos, buf_pos,
242
242
    min(chroma_width, 40));
243
243
 
244
244
  buf_pos = buf + 16 + offs3;
245
245
  offs = le2me_32(*(uint32_t *)buf_pos);
246
246
  buf_pos += 4;
247
247
 
248
 
  iv_Decode_Chunk(s, s->cur_frame->Ubuf, s->ref_frame->Ubuf, chroma_width, 
249
 
    chroma_height, buf_pos + offs * 2, fflags2, hdr_pos, buf_pos, 
 
248
  iv_Decode_Chunk(s, s->cur_frame->Ubuf, s->ref_frame->Ubuf, chroma_width,
 
249
    chroma_height, buf_pos + offs * 2, fflags2, hdr_pos, buf_pos,
250
250
    min(chroma_width, 40));
251
251
 
252
252
  }
309
309
  lp2 = 4;
310
310
 
311
311
static void iv_Decode_Chunk(Indeo3DecodeContext *s,
312
 
  unsigned char *cur, unsigned char *ref, int width, int height, 
 
312
  unsigned char *cur, unsigned char *ref, int width, int height,
313
313
  unsigned char *buf1, long fflags2, unsigned char *hdr,
314
314
  unsigned char *buf2, int min_width_160)
315
315
{
331
331
 
332
332
  width_tbl = width_tbl_arr + 1;
333
333
  i = (width < 0 ? width + 3 : width)/4;
334
 
  for(j = -1; j < 8; j++) 
 
334
  for(j = -1; j < 8; j++)
335
335
    width_tbl[j] = i * j;
336
336
 
337
337
  strip = strip_tbl;
389
389
 
390
390
    cur_frm_pos = cur + width * strip->ypos + strip->xpos;
391
391
 
392
 
    if((blks_width = strip->width) < 0) 
 
392
    if((blks_width = strip->width) < 0)
393
393
      blks_width += 3;
394
394
    blks_width >>= 2;
395
395
    blks_height = strip->height;
397
397
    if(ref_vectors != NULL) {
398
398
      ref_frm_pos = ref + (ref_vectors[0] + strip->ypos) * width +
399
399
        ref_vectors[1] + strip->xpos;
400
 
    } else 
 
400
    } else
401
401
      ref_frm_pos = cur_frm_pos - width_tbl[4];
402
402
 
403
403
    if(cmd == 2) {
416
416
          cur_frm_pos += 4;
417
417
          ref_frm_pos += 4;
418
418
        }
419
 
      } else if(cmd != 1) 
 
419
      } else if(cmd != 1)
420
420
        return;
421
421
    } else {
422
422
      k = *buf1 >> 4;
427
427
      if((lv - 8) <= 7 && (k == 0 || k == 3 || k == 10)) {
428
428
        cp2 = s->ModPred + ((lv - 8) << 7);
429
429
        cp = ref_frm_pos;
430
 
        for(i = 0; i < blks_width << 2; i++) { 
 
430
        for(i = 0; i < blks_width << 2; i++) {
431
431
            int v = *cp >> 1;
432
 
            *(cp++) = cp2[v]; 
 
432
            *(cp++) = cp2[v];
433
433
        }
434
434
      }
435
435
 
508
508
                    break;
509
509
 
510
510
                  case 7:
511
 
                    if(rle_v3 != 0) 
 
511
                    if(rle_v3 != 0)
512
512
                      rle_v3 = 0;
513
513
                    else {
514
514
                      buf1--;
532
532
 
533
533
                    LV1_CHECK(buf1,rle_v3,lv1,lp2)
534
534
                    break;
535
 
                  default: 
 
535
                  default:
536
536
                    return;
537
537
                }
538
538
              }
548
548
 
549
549
        case 4:
550
550
        case 3:                    /********** CASE 3 **********/
551
 
          if(ref_vectors != NULL) 
 
551
          if(ref_vectors != NULL)
552
552
            return;
553
553
          flag1 = 1;
554
554
 
605
605
                    break;
606
606
 
607
607
                  case 7:
608
 
                    if(rle_v3 != 0) 
 
608
                    if(rle_v3 != 0)
609
609
                      rle_v3 = 0;
610
610
                    else {
611
611
                      buf1--;
650
650
                    LV1_CHECK(buf1,rle_v3,lv1,lp2)
651
651
                    break;
652
652
 
653
 
                  default: 
 
653
                  default:
654
654
                    return;
655
655
                }
656
656
              }
804
804
 
805
805
                    case 7:
806
806
                      if(lp2 == 0) {
807
 
                        if(rle_v3 != 0) 
 
807
                        if(rle_v3 != 0)
808
808
                          rle_v3 = 0;
809
809
                        else {
810
810
                          buf1--;
825
825
                      LV1_CHECK(buf1,rle_v3,lv1,lp2)
826
826
                      break;
827
827
 
828
 
                    default: 
 
828
                    default:
829
829
                      return;
830
830
                  }
831
831
                }
921
921
                      LV1_CHECK(buf1,rle_v3,lv1,lp2)
922
922
                      break;
923
923
 
924
 
                    default: 
 
924
                    default:
925
925
                      return;
926
926
                  }
927
927
                }
937
937
          break;
938
938
 
939
939
        case 11:                    /********** CASE 11 **********/
940
 
          if(ref_vectors == NULL) 
 
940
          if(ref_vectors == NULL)
941
941
            return;
942
942
 
943
943
          for( ; blks_height > 0; blks_height -= 8) {
1018
1018
                  LV1_CHECK(buf1,rle_v3,lv1,lp2)
1019
1019
                  break;
1020
1020
 
1021
 
                  default: 
 
1021
                  default:
1022
1022
                    return;
1023
1023
                }
1024
1024
              }
1032
1032
          }
1033
1033
          break;
1034
1034
 
1035
 
        default: 
 
1035
        default:
1036
1036
          return;
1037
1037
      }
1038
1038
    }
1039
1039
 
1040
 
    if(strip < strip_tbl) 
 
1040
    if(strip < strip_tbl)
1041
1041
      return;
1042
1042
 
1043
1043
    for( ; strip >= strip_tbl; strip--) {