Subversion Repositories shark

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
1624 giacomo 1
/* store.c, picture output routines                                         */
2
 
3
/* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
4
 
5
/*
6
 * Disclaimer of Warranty
7
 *
8
 * These software programs are available to the user without any license fee or
9
 * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
10
 * any and all warranties, whether express, implied, or statuary, including any
11
 * implied warranties or merchantability or of fitness for a particular
12
 * purpose.  In no event shall the copyright-holder be liable for any
13
 * incidental, punitive, or consequential damages of any kind whatsoever
14
 * arising from the use of these programs.
15
 *
16
 * This disclaimer of warranty extends to the user of these programs and user's
17
 * customers, employees, agents, transferees, successors, and assigns.
18
 *
19
 * The MPEG Software Simulation Group does not represent or warrant that the
20
 * programs furnished hereunder are free of infringement of any third-party
21
 * patents.
22
 *
23
 * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
24
 * are subject to royalty fees to patent holders.  Many of these patents are
25
 * general enough such that they are unavoidable regardless of implementation
26
 * design.
27
 *
28
 */
29
 
30
#include <stdio.h>
31
#include <stdlib.h>
32
#include <fcntl.h>
33
 
34
#include "config.h"
35
#include "global.h"
36
 
37
/* private prototypes */
38
static void store_one _ANSI_ARGS_((char *outname, unsigned char *src[],
39
  int offset, int incr, int height));
40
static void store_yuv _ANSI_ARGS_((char *outname, unsigned char *src[],
41
  int offset, int incr, int height));
42
static void store_sif _ANSI_ARGS_((char *outname, unsigned char *src[],
43
  int offset, int incr, int height));
44
static void store_ppm_tga _ANSI_ARGS_((char *outname, unsigned char *src[],
45
  int offset, int incr, int height, int tgaflag));
46
static void store_yuv1 _ANSI_ARGS_((char *name, unsigned char *src,
47
  int offset, int incr, int width, int height));
48
static void putbyte _ANSI_ARGS_((int c));
49
static void putword _ANSI_ARGS_((int w));
50
static void conv422to444 _ANSI_ARGS_((unsigned char *src, unsigned char *dst));
51
static void conv420to422 _ANSI_ARGS_((unsigned char *src, unsigned char *dst));
52
 
53
#define OBFRSIZE 4096
54
static unsigned char obfr[OBFRSIZE];
55
static unsigned char *optr;
56
static int outfile;
57
 
58
/*
59
 * store a picture as either one frame or two fields
60
 */
61
void Write_Frame(src,frame)
62
unsigned char *src[];
63
int frame;
64
{
65
  char outname[FILENAME_LENGTH];
66
 
67
  if (progressive_sequence || progressive_frame || Frame_Store_Flag)
68
  {
69
    /* progressive */
70
    sprintf(outname,Output_Picture_Filename,frame,'f');
71
    store_one(outname,src,0,Coded_Picture_Width,vertical_size);
72
  }
73
  else
74
  {
75
    /* interlaced */
76
    sprintf(outname,Output_Picture_Filename,frame,'a');
77
    store_one(outname,src,0,Coded_Picture_Width<<1,vertical_size>>1);
78
 
79
    sprintf(outname,Output_Picture_Filename,frame,'b');
80
    store_one(outname,src,
81
      Coded_Picture_Width,Coded_Picture_Width<<1,vertical_size>>1);
82
  }
83
}
84
 
85
/*
86
 * store one frame or one field
87
 */
88
static void store_one(outname,src,offset,incr,height)
89
char *outname;
90
unsigned char *src[];
91
int offset, incr, height;
92
{
93
  switch (Output_Type)
94
  {
95
  case T_YUV:
96
    store_yuv(outname,src,offset,incr,height);
97
    break;
98
  case T_SIF:
99
    store_sif(outname,src,offset,incr,height);
100
    break;
101
  case T_TGA:
102
    store_ppm_tga(outname,src,offset,incr,height,1);
103
    break;
104
  case T_PPM:
105
    store_ppm_tga(outname,src,offset,incr,height,0);
106
    break;
107
#ifdef DISPLAY
108
  case T_X11:
109
    dither(src);
110
    break;
111
#endif
112
  default:
113
    break;
114
  }
115
}
116
 
117
/* separate headerless files for y, u and v */
118
static void store_yuv(outname,src,offset,incr,height)
119
char *outname;
120
unsigned char *src[];
121
int offset,incr,height;
122
{
123
  int hsize;
124
  char tmpname[FILENAME_LENGTH];
125
 
126
  hsize = horizontal_size;
127
 
128
  sprintf(tmpname,"%s.Y",outname);
129
  store_yuv1(tmpname,src[0],offset,incr,hsize,height);
130
 
131
  if (chroma_format!=CHROMA444)
132
  {
133
    offset>>=1; incr>>=1; hsize>>=1;
134
  }
135
 
136
  if (chroma_format==CHROMA420)
137
  {
138
    height>>=1;
139
  }
140
 
141
  sprintf(tmpname,"%s.U",outname);
142
  store_yuv1(tmpname,src[1],offset,incr,hsize,height);
143
 
144
  sprintf(tmpname,"%s.V",outname);
145
  store_yuv1(tmpname,src[2],offset,incr,hsize,height);
146
}
147
 
148
/* auxiliary routine */
149
static void store_yuv1(name,src,offset,incr,width,height)
150
char *name;
151
unsigned char *src;
152
int offset,incr,width,height;
153
{
154
  int i, j;
155
  unsigned char *p;
156
 
157
  if (!Quiet_Flag)
158
    fprintf(stderr,"saving %s\n",name);
159
 
160
  if ((outfile = open(name,O_CREAT|O_TRUNC|O_WRONLY|O_BINARY,0666))==-1)
161
  {
162
    sprintf(Error_Text,"Couldn't create %s\n",name);
163
    Error(Error_Text);
164
  }
165
 
166
  optr=obfr;
167
 
168
  for (i=0; i<height; i++)
169
  {
170
    p = src + offset + incr*i;
171
    for (j=0; j<width; j++)
172
      putbyte(*p++);
173
  }
174
 
175
  if (optr!=obfr)
176
    write(outfile,obfr,optr-obfr);
177
 
178
  close(outfile);
179
}
180
 
181
/*
182
 * store as headerless file in U,Y,V,Y format
183
 */
184
static void store_sif (outname,src,offset,incr,height)
185
char *outname;
186
unsigned char *src[];
187
int offset, incr, height;
188
{
189
  int i,j;
190
  unsigned char *py, *pu, *pv;
191
  static unsigned char *u422, *v422;
192
 
193
  if (chroma_format==CHROMA444)
194
    Error("4:4:4 not supported for SIF format");
195
 
196
  if (chroma_format==CHROMA422)
197
  {
198
    u422 = src[1];
199
    v422 = src[2];
200
  }
201
  else
202
  {
203
    if (!u422)
204
    {
205
      if (!(u422 = (unsigned char *)malloc((Coded_Picture_Width>>1)
206
                                           *Coded_Picture_Height)))
207
        Error("malloc failed");
208
      if (!(v422 = (unsigned char *)malloc((Coded_Picture_Width>>1)
209
                                           *Coded_Picture_Height)))
210
        Error("malloc failed");
211
    }
212
 
213
    conv420to422(src[1],u422);
214
    conv420to422(src[2],v422);
215
  }
216
 
217
  strcat(outname,".SIF");
218
 
219
  if (!Quiet_Flag)
220
    fprintf(stderr,"saving %s\n",outname);
221
 
222
  if ((outfile = open(outname,O_CREAT|O_TRUNC|O_WRONLY|O_BINARY,0666))==-1)
223
  {
224
    sprintf(Error_Text,"Couldn't create %s\n",outname);
225
    Error(Error_Text);
226
  }
227
 
228
  optr = obfr;
229
 
230
  for (i=0; i<height; i++)
231
  {
232
    py = src[0] + offset + incr*i;
233
    pu = u422 + (offset>>1) + (incr>>1)*i;
234
    pv = v422 + (offset>>1) + (incr>>1)*i;
235
 
236
    for (j=0; j<horizontal_size; j+=2)
237
    {
238
      putbyte(*pu++);
239
      putbyte(*py++);
240
      putbyte(*pv++);
241
      putbyte(*py++);
242
    }
243
  }
244
 
245
  if (optr!=obfr)
246
    write(outfile,obfr,optr-obfr);
247
 
248
  close(outfile);
249
}
250
 
251
/*
252
 * store as PPM (PBMPLUS) or uncompressed Truevision TGA ('Targa') file
253
 */
254
static void store_ppm_tga(outname,src,offset,incr,height,tgaflag)
255
char *outname;
256
unsigned char *src[];
257
int offset, incr, height;
258
int tgaflag;
259
{
260
  int i, j;
261
  int y, u, v, r, g, b;
262
  int crv, cbu, cgu, cgv;
263
  unsigned char *py, *pu, *pv;
264
  static unsigned char tga24[14] = {0,0,2,0,0,0,0, 0,0,0,0,0,24,32};
265
  char header[FILENAME_LENGTH];
266
  static unsigned char *u422, *v422, *u444, *v444;
267
 
268
  if (chroma_format==CHROMA444)
269
  {
270
    u444 = src[1];
271
    v444 = src[2];
272
  }
273
  else
274
  {
275
    if (!u444)
276
    {
277
      if (chroma_format==CHROMA420)
278
      {
279
        if (!(u422 = (unsigned char *)malloc((Coded_Picture_Width>>1)
280
                                             *Coded_Picture_Height)))
281
          Error("malloc failed");
282
        if (!(v422 = (unsigned char *)malloc((Coded_Picture_Width>>1)
283
                                             *Coded_Picture_Height)))
284
          Error("malloc failed");
285
      }
286
 
287
      if (!(u444 = (unsigned char *)malloc(Coded_Picture_Width
288
                                           *Coded_Picture_Height)))
289
        Error("malloc failed");
290
 
291
      if (!(v444 = (unsigned char *)malloc(Coded_Picture_Width
292
                                           *Coded_Picture_Height)))
293
        Error("malloc failed");
294
    }
295
 
296
    if (chroma_format==CHROMA420)
297
    {
298
      conv420to422(src[1],u422);
299
      conv420to422(src[2],v422);
300
      conv422to444(u422,u444);
301
      conv422to444(v422,v444);
302
    }
303
    else
304
    {
305
      conv422to444(src[1],u444);
306
      conv422to444(src[2],v444);
307
    }
308
  }
309
 
310
  strcat(outname,tgaflag ? ".tga" : ".ppm");
311
 
312
  if (!Quiet_Flag)
313
    fprintf(stderr,"saving %s\n",outname);
314
 
315
  if ((outfile = open(outname,O_CREAT|O_TRUNC|O_WRONLY|O_BINARY,0666))==-1)
316
  {
317
    sprintf(Error_Text,"Couldn't create %s\n",outname);
318
    Error(Error_Text);
319
  }
320
 
321
  optr = obfr;
322
 
323
  if (tgaflag)
324
  {
325
    /* TGA header */
326
    for (i=0; i<12; i++)
327
      putbyte(tga24[i]);
328
 
329
    putword(horizontal_size); putword(height);
330
    putbyte(tga24[12]); putbyte(tga24[13]);
331
  }
332
  else
333
  {
334
    /* PPM header */
335
    sprintf(header,"P6\n%d %d\n255\n",horizontal_size,height);
336
 
337
    for (i=0; header[i]!=0; i++)
338
      putbyte(header[i]);
339
  }
340
 
341
  /* matrix coefficients */
342
  crv = Inverse_Table_6_9[matrix_coefficients][0];
343
  cbu = Inverse_Table_6_9[matrix_coefficients][1];
344
  cgu = Inverse_Table_6_9[matrix_coefficients][2];
345
  cgv = Inverse_Table_6_9[matrix_coefficients][3];
346
 
347
  for (i=0; i<height; i++)
348
  {
349
    py = src[0] + offset + incr*i;
350
    pu = u444 + offset + incr*i;
351
    pv = v444 + offset + incr*i;
352
 
353
    for (j=0; j<horizontal_size; j++)
354
    {
355
      u = *pu++ - 128;
356
      v = *pv++ - 128;
357
      y = 76309 * (*py++ - 16); /* (255/219)*65536 */
358
      r = Clip[(y + crv*v + 32768)>>16];
359
      g = Clip[(y - cgu*u - cgv*v + 32768)>>16];
360
      b = Clip[(y + cbu*u + 32786)>>16];
361
 
362
      if (tgaflag)
363
      {
364
        putbyte(b); putbyte(g); putbyte(r);
365
      }
366
      else
367
      {
368
        putbyte(r); putbyte(g); putbyte(b);
369
      }
370
    }
371
  }
372
 
373
  if (optr!=obfr)
374
    write(outfile,obfr,optr-obfr);
375
 
376
  close(outfile);
377
}
378
 
379
static void putbyte(c)
380
int c;
381
{
382
  *optr++ = c;
383
 
384
  if (optr == obfr+OBFRSIZE)
385
  {
386
    write(outfile,obfr,OBFRSIZE);
387
    optr = obfr;
388
  }
389
}
390
 
391
static void putword(w)
392
int w;
393
{
394
  putbyte(w); putbyte(w>>8);
395
}
396
 
397
/* horizontal 1:2 interpolation filter */
398
static void conv422to444(src,dst)
399
unsigned char *src,*dst;
400
{
401
  int i, i2, w, j, im3, im2, im1, ip1, ip2, ip3;
402
 
403
  w = Coded_Picture_Width>>1;
404
 
405
  if (base.MPEG2_Flag)
406
  {
407
    for (j=0; j<Coded_Picture_Height; j++)
408
    {
409
      for (i=0; i<w; i++)
410
      {
411
        i2 = i<<1;
412
        im2 = (i<2) ? 0 : i-2;
413
        im1 = (i<1) ? 0 : i-1;
414
        ip1 = (i<w-1) ? i+1 : w-1;
415
        ip2 = (i<w-2) ? i+2 : w-1;
416
        ip3 = (i<w-3) ? i+3 : w-1;
417
 
418
        /* FIR filter coefficients (*256): 21 0 -52 0 159 256 159 0 -52 0 21 */
419
        /* even samples (0 0 256 0 0) */
420
        dst[i2] = src[i];
421
 
422
        /* odd samples (21 -52 159 159 -52 21) */
423
        dst[i2+1] = Clip[(int)(21*(src[im2]+src[ip3])
424
                        -52*(src[im1]+src[ip2])
425
                       +159*(src[i]+src[ip1])+128)>>8];
426
      }
427
      src+= w;
428
      dst+= Coded_Picture_Width;
429
    }
430
  }
431
  else
432
  {
433
    for (j=0; j<Coded_Picture_Height; j++)
434
    {
435
      for (i=0; i<w; i++)
436
      {
437
 
438
        i2 = i<<1;
439
        im3 = (i<3) ? 0 : i-3;
440
        im2 = (i<2) ? 0 : i-2;
441
        im1 = (i<1) ? 0 : i-1;
442
        ip1 = (i<w-1) ? i+1 : w-1;
443
        ip2 = (i<w-2) ? i+2 : w-1;
444
        ip3 = (i<w-3) ? i+3 : w-1;
445
 
446
        /* FIR filter coefficients (*256): 5 -21 70 228 -37 11 */
447
        dst[i2] =   Clip[(int)(  5*src[im3]
448
                         -21*src[im2]
449
                         +70*src[im1]
450
                        +228*src[i]
451
                         -37*src[ip1]
452
                         +11*src[ip2]+128)>>8];
453
 
454
       dst[i2+1] = Clip[(int)(  5*src[ip3]
455
                         -21*src[ip2]
456
                         +70*src[ip1]
457
                        +228*src[i]
458
                         -37*src[im1]
459
                         +11*src[im2]+128)>>8];
460
      }
461
      src+= w;
462
      dst+= Coded_Picture_Width;
463
    }
464
  }
465
}
466
 
467
/* vertical 1:2 interpolation filter */
468
static void conv420to422(src,dst)
469
unsigned char *src,*dst;
470
{
471
  int w, h, i, j, j2;
472
  int jm6, jm5, jm4, jm3, jm2, jm1, jp1, jp2, jp3, jp4, jp5, jp6, jp7;
473
 
474
  w = Coded_Picture_Width>>1;
475
  h = Coded_Picture_Height>>1;
476
 
477
  if (progressive_frame)
478
  {
479
    /* intra frame */
480
    for (i=0; i<w; i++)
481
    {
482
      for (j=0; j<h; j++)
483
      {
484
        j2 = j<<1;
485
        jm3 = (j<3) ? 0 : j-3;
486
        jm2 = (j<2) ? 0 : j-2;
487
        jm1 = (j<1) ? 0 : j-1;
488
        jp1 = (j<h-1) ? j+1 : h-1;
489
        jp2 = (j<h-2) ? j+2 : h-1;
490
        jp3 = (j<h-3) ? j+3 : h-1;
491
 
492
        /* FIR filter coefficients (*256): 5 -21 70 228 -37 11 */
493
        /* New FIR filter coefficients (*256): 3 -16 67 227 -32 7 */
494
        dst[w*j2] =     Clip[(int)(  3*src[w*jm3]
495
                             -16*src[w*jm2]
496
                             +67*src[w*jm1]
497
                            +227*src[w*j]
498
                             -32*src[w*jp1]
499
                             +7*src[w*jp2]+128)>>8];
500
 
501
        dst[w*(j2+1)] = Clip[(int)(  3*src[w*jp3]
502
                             -16*src[w*jp2]
503
                             +67*src[w*jp1]
504
                            +227*src[w*j]
505
                             -32*src[w*jm1]
506
                             +7*src[w*jm2]+128)>>8];
507
      }
508
      src++;
509
      dst++;
510
    }
511
  }
512
  else
513
  {
514
    /* intra field */
515
    for (i=0; i<w; i++)
516
    {
517
      for (j=0; j<h; j+=2)
518
      {
519
        j2 = j<<1;
520
 
521
        /* top field */
522
        jm6 = (j<6) ? 0 : j-6;
523
        jm4 = (j<4) ? 0 : j-4;
524
        jm2 = (j<2) ? 0 : j-2;
525
        jp2 = (j<h-2) ? j+2 : h-2;
526
        jp4 = (j<h-4) ? j+4 : h-2;
527
        jp6 = (j<h-6) ? j+6 : h-2;
528
 
529
        /* Polyphase FIR filter coefficients (*256): 2 -10 35 242 -18 5 */
530
        /* New polyphase FIR filter coefficients (*256): 1 -7 30 248 -21 5 */
531
        dst[w*j2] = Clip[(int)(  1*src[w*jm6]
532
                         -7*src[w*jm4]
533
                         +30*src[w*jm2]
534
                        +248*src[w*j]
535
                         -21*src[w*jp2]
536
                          +5*src[w*jp4]+128)>>8];
537
 
538
        /* Polyphase FIR filter coefficients (*256): 11 -38 192 113 -30 8 */
539
        /* New polyphase FIR filter coefficients (*256):7 -35 194 110 -24 4 */
540
        dst[w*(j2+2)] = Clip[(int)( 7*src[w*jm4]
541
                             -35*src[w*jm2]
542
                            +194*src[w*j]
543
                            +110*src[w*jp2]
544
                             -24*src[w*jp4]
545
                              +4*src[w*jp6]+128)>>8];
546
 
547
        /* bottom field */
548
        jm5 = (j<5) ? 1 : j-5;
549
        jm3 = (j<3) ? 1 : j-3;
550
        jm1 = (j<1) ? 1 : j-1;
551
        jp1 = (j<h-1) ? j+1 : h-1;
552
        jp3 = (j<h-3) ? j+3 : h-1;
553
        jp5 = (j<h-5) ? j+5 : h-1;
554
        jp7 = (j<h-7) ? j+7 : h-1;
555
 
556
        /* Polyphase FIR filter coefficients (*256): 11 -38 192 113 -30 8 */
557
        /* New polyphase FIR filter coefficients (*256):7 -35 194 110 -24 4 */
558
        dst[w*(j2+1)] = Clip[(int)( 7*src[w*jp5]
559
                             -35*src[w*jp3]
560
                            +194*src[w*jp1]
561
                            +110*src[w*jm1]
562
                             -24*src[w*jm3]
563
                              +4*src[w*jm5]+128)>>8];
564
 
565
        dst[w*(j2+3)] = Clip[(int)(  1*src[w*jp7]
566
                             -7*src[w*jp5]
567
                             +30*src[w*jp3]
568
                            +248*src[w*jp1]
569
                             -21*src[w*jm1]
570
                              +5*src[w*jm3]+128)>>8];
571
      }
572
      src++;
573
      dst++;
574
    }
575
  }
576
}