cvd_parse.c
上传用户:riyaled888
上传日期:2009-03-27
资源大小:7338k
文件大小:18k
源码类别:

多媒体

开发平台:

MultiPlatform

  1. /*****************************************************************************
  2.  * parse.c: Philips OGT (SVCD subtitle) packet parser
  3.  *****************************************************************************
  4.  * Copyright (C) 2003, 2004 VideoLAN
  5.  * $Id: cvd_parse.c 8709 2004-09-15 15:50:54Z gbazin $
  6.  *
  7.  * Authors: Rocky Bernstein 
  8.  *   based on code from: 
  9.  *       Julio Sanchez Fernandez (http://subhandler.sourceforge.net)
  10.  *       Sam Hocevar <sam@zoy.org>
  11.  *       Laurent Aimar <fenrir@via.ecp.fr>
  12.  *
  13.  * This program is free software; you can redistribute it and/or modify
  14.  * it under the terms of the GNU General Public License as published by
  15.  * the Free Software Foundation; either version 2 of the License, or
  16.  * (at your option) any later version.
  17.  *
  18.  * This program is distributed in the hope that it will be useful,
  19.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.  * GNU General Public License for more details.
  22.  *
  23.  * You should have received a copy of the GNU General Public License
  24.  * along with this program; if not, write to the Free Software
  25.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  26.  *****************************************************************************/
  27. /*****************************************************************************
  28.  * Preamble
  29.  *****************************************************************************/
  30. #include <vlc/vlc.h>
  31. #include <vlc/vout.h>
  32. #include <vlc/decoder.h>
  33. #include "subtitle.h"
  34. #include "render.h"
  35. #include "cvd.h"
  36. #include "common.h"
  37. #ifdef HAVE_LIBPNG
  38. #include <png.h>
  39. #endif
  40. /* An image color is a two-bit palette entry: 0..3 */ 
  41. typedef uint8_t ogt_color_t;
  42. /*****************************************************************************
  43.  * Local prototypes.
  44.  *****************************************************************************/
  45. static int  ParseImage         ( decoder_t *, subpicture_t * );
  46. /*
  47.   We do not have information on the subtitle format used on CVD's
  48.   except the submux sample code and a couple of samples of dubious
  49.   origin. Thus, this is the result of reading some code whose
  50.   correctness is not known and some experimentation.
  51.   
  52.   CVD subtitles are different in several ways from SVCD OGT subtitles.
  53.   Image comes first and metadata is at the end.  So that the metadata
  54.   can be found easily, the subtitle packet starts with two bytes
  55.   (everything is big-endian again) that give the total size of the
  56.   subtitle data and the offset to the metadata - i.e. size of the
  57.   image data plus the four bytes at the beginning.
  58.  
  59.   Image data comes interlaced is run-length encoded.  Each field is a
  60.   four-bit nibble. Each nibble contains a two-bit repeat count and a
  61.   two-bit color number so that up to three pixels can be described in
  62.   four bits.  The function of a 0 repeat count is unknown; it might be
  63.   used for RLE extension.  However when the full nibble is zero, the
  64.   rest of the line is filled with the color value in the next nibble.
  65.   It is unknown what happens if the color value is greater than three.
  66.   The rest seems to use a 4-entries palette.  It is not impossible
  67.   that the fill-line complete case above is not as described and the
  68.   zero repeat count means fill line.  The sample code never produces
  69.   this, so it may be untested.
  70. */
  71. void E_(ParseHeader)( decoder_t *p_dec, uint8_t *p_buffer, block_t *p_block )
  72. {
  73.   decoder_sys_t *p_sys = p_dec->p_sys;
  74.   uint8_t *p = p_buffer+1;
  75.   dbg_print( (DECODE_DBG_CALL|DECODE_DBG_PACKET), 
  76.      "header: 0x%02x 0x%02x 0x%02x 0x%02x, 0x%02x, 0x%02x, size: %i",
  77.      p_buffer[0], p_buffer[1], p_buffer[2], p_buffer[3],
  78.      p_buffer[4], p_buffer[5],
  79.      p_block->i_buffer);
  80.   
  81.   dbg_print( (DECODE_DBG_CALL|DECODE_DBG_EXT) , "");
  82.   p_sys->i_pts    = p_block->i_pts;
  83.   p_sys->i_spu_size = (p[0] << 8) + p[1] + 4; p += 2;
  84.   /* FIXME: check data sanity */
  85.   p_sys->metadata_offset = GETINT16(p);
  86.   p_sys->metadata_length = p_sys->i_spu_size - p_sys->metadata_offset;
  87.   p_sys->i_image_offset = 4;
  88.   p_sys->i_image_length = p_sys->metadata_offset - p_sys->i_image_offset;
  89.   
  90.   dbg_print(DECODE_DBG_PACKET, "total size: %d  image size: %dn",
  91.     p_sys->i_spu_size, p_sys->i_image_length);
  92. }
  93. #define ExtractXY(x, y)     
  94.   x = ((p[1]&0x0f)<<6) + (p[2]>>2); 
  95.   y = ((p[2]&0x03)<<8) + p[3];
  96. /* 
  97.   We parse the metadata information here. 
  98.   Although metadata information does not have to come in a fixed field
  99.   order, every metadata field consists of a tag byte followed by
  100.   parameters. In all cases known, the size including tag byte is
  101.   exactly four bytes in length.
  102. */
  103. void E_(ParseMetaInfo)( decoder_t *p_dec  )
  104. {
  105.   /* last packet in subtitle block. */
  106.   
  107.   decoder_sys_t *p_sys = p_dec->p_sys;
  108.   uint8_t       *p     = p_sys->subtitle_data + p_sys->metadata_offset;
  109.   uint8_t       *p_end = p + p_sys->metadata_length;
  110.   
  111.   dbg_print( (DECODE_DBG_PACKET),
  112.      "subtitle packet complete, size=%d", p_sys->i_spu );
  113.   
  114.   p_sys->state = SUBTITLE_BLOCK_COMPLETE;
  115.   p_sys->i_image++;
  116.   
  117.   for ( ; p < p_end; p += 4 ) {
  118.     
  119.     switch ( p[0] ) {
  120.       
  121.     case 0x04: /* subtitle duration in 1/90000ths of a second */
  122.       {
  123. mtime_t i_duration = (p[1]<<16) + (p[2]<<8) + p[3];
  124. mtime_t i_duration_scale = config_GetInt( p_dec, MODULE_STRING 
  125.      "-duration-scaling" );
  126. dbg_print( DECODE_DBG_PACKET, 
  127.    "subtitle display duration %lu secs  (scaled %lu secs)", 
  128.    (long unsigned int) (i_duration / 90000), 
  129.    (long unsigned int) (i_duration * i_duration_scale / 90000)
  130.    );
  131. p_sys->i_duration = i_duration * i_duration_scale ;
  132. break;
  133.       }
  134.       
  135.       
  136.     case 0x0c: /* unknown */
  137.       dbg_print( DECODE_DBG_PACKET, 
  138.  "subtitle command unknown 0x%0x 0x%0x 0x%0x 0x%0xn",
  139.  p[0], p[1], p[2], p[3]);
  140.       break;
  141.       
  142.     case 0x17: /* coordinates of subtitle upper left x, y position */
  143.       ExtractXY(p_sys->i_x_start, p_sys->i_y_start);
  144.       break;
  145.       
  146.     case 0x1f: /* coordinates of subtitle bottom right x, y position */
  147.       {
  148. int lastx;
  149. int lasty;
  150. ExtractXY(lastx, lasty);
  151. p_sys->i_width  = lastx - p_sys->i_x_start + 1;
  152. p_sys->i_height = lasty - p_sys->i_y_start + 1;
  153. dbg_print( DECODE_DBG_PACKET, 
  154.    "end position: (%d,%d): %.2x %.2x %.2x, w x h: %dx%d",
  155.    lastx, lasty, p[1], p[2], p[3], 
  156.    p_sys->i_width, p_sys->i_height );
  157. break;
  158.       }
  159.       
  160.       
  161.     case 0x24:
  162.     case 0x25:
  163.     case 0x26:
  164.     case 0x27: 
  165.       {
  166. uint8_t v = p[0]-0x24;
  167. /* Primary Palette */
  168. dbg_print( DECODE_DBG_PACKET,
  169.    "primary palette %d (y,u,v): (0x%0x,0x%0x,0x%0x)",
  170.    v, p[1], p[2], p[3]);
  171. p_sys->p_palette[v].s.y = p[1];
  172. p_sys->p_palette[v].s.u = p[2];
  173. p_sys->p_palette[v].s.v = p[3];
  174. break;
  175.       }
  176.       
  177.       
  178.     case 0x2c:
  179.     case 0x2d:
  180.     case 0x2e:
  181.     case 0x2f:
  182.       {
  183. uint8_t v = p[0]-0x2c;
  184. dbg_print( DECODE_DBG_PACKET,
  185.    "highlight palette %d (y,u,v): (0x%0x,0x%0x,0x%0x)",
  186.    v, p[1], p[2], p[3]);
  187. /* Highlight Palette */
  188. p_sys->p_palette_highlight[v].s.y = p[1];
  189. p_sys->p_palette_highlight[v].s.u = p[2];
  190. p_sys->p_palette_highlight[v].s.v = p[3];
  191. break;
  192.       }
  193.       
  194.     case 0x37:
  195.       /* transparency for primary palette */
  196.       p_sys->p_palette[0].s.t = p[3] & 0x0f;
  197.       p_sys->p_palette[1].s.t = p[3] >> 4;
  198.       p_sys->p_palette[2].s.t = p[2] & 0x0f;
  199.       p_sys->p_palette[3].s.t = p[2] >> 4;
  200.       
  201.       dbg_print( DECODE_DBG_PACKET,
  202.  "transparency for primary palette 0..3: "
  203.  "0x%0x 0x%0x 0x%0x 0x%0x",
  204.  p_sys->p_palette[0].s.t,
  205.  p_sys->p_palette[1].s.t,
  206.  p_sys->p_palette[2].s.t,
  207.  p_sys->p_palette[3].s.t );
  208.       
  209.       break;
  210.       
  211.     case 0x3f:
  212.       /* transparency for highlight palette */
  213.       p_sys->p_palette_highlight[0].s.t = p[2] & 0x0f;
  214.       p_sys->p_palette_highlight[1].s.t = p[2] >> 4;
  215.       p_sys->p_palette_highlight[2].s.t = p[1] & 0x0f;
  216.       p_sys->p_palette_highlight[3].s.t = p[1] >> 4;
  217.       
  218.       dbg_print( DECODE_DBG_PACKET,
  219.  "transparency for primary palette 0..3: "
  220.  "0x%0x 0x%0x 0x%0x 0x%0x",
  221.  p_sys->p_palette_highlight[0].s.t,
  222.  p_sys->p_palette_highlight[1].s.t,
  223.  p_sys->p_palette_highlight[2].s.t,
  224.  p_sys->p_palette_highlight[3].s.t );
  225.       
  226.       break;
  227.       
  228.     case 0x47:
  229.       /* offset to start of even rows of interlaced image, we correct
  230.  to make it relative to i_image_offset (usually 4) */
  231.       p_sys->first_field_offset =
  232. (p[2] << 8) + p[3] - p_sys->i_image_offset;
  233.       dbg_print( DECODE_DBG_PACKET, 
  234.  "first_field_offset %d", p_sys->first_field_offset);
  235.       break;
  236.       
  237.     case 0x4f:
  238.       /* offset to start of odd rows of interlaced image, we correct
  239.  to make it relative to i_image_offset (usually 4) */
  240.       p_sys->second_field_offset =
  241. (p[2] << 8) + p[3] - p_sys->i_image_offset;
  242.       dbg_print( DECODE_DBG_PACKET, 
  243.  "second_field_offset %d", p_sys->second_field_offset);
  244.       break;
  245.       
  246.     default:
  247.       msg_Warn( p_dec, 
  248. "unknown sequence in control header " 
  249. "0x%0x 0x%0x 0x%0x 0x%0x",
  250. p[0], p[1], p[2], p[3]);
  251.       
  252.       p_sys->subtitle_data_pos = 0;
  253.     }
  254.   }
  255. }
  256. /*****************************************************************************
  257.  * ParsePacket: parse an SPU packet and send it to the video output
  258.  *****************************************************************************
  259.  * This function parses the SPU packet and, if valid, sends it to the
  260.  * video output.
  261.  *****************************************************************************/
  262. void 
  263. E_(ParsePacket)( decoder_t *p_dec)
  264. {
  265.     decoder_sys_t *p_sys = p_dec->p_sys;
  266.     subpicture_t  *p_spu;
  267.     dbg_print( (DECODE_DBG_CALL|DECODE_DBG_EXT) , "");
  268.     /* Allocate the subpicture internal data. */
  269.     p_spu = spu_CreateSubpicture( p_sys->p_vout->p_spu );
  270.     if( p_spu == NULL ) return;
  271.     p_spu->i_channel = p_sys->i_subpic_channel;
  272.     /* In ParseImage we expand the run-length encoded color 0's; also
  273.        we expand pixels and remove the color palette. This should
  274.        facilitate scaling and antialiasing and speed up rendering.
  275.     */
  276.     p_spu->p_sys = malloc( sizeof( subpicture_sys_t ) 
  277.    + PIXEL_SIZE * (p_sys->i_width * p_sys->i_height) );
  278.     /* Fill the p_spu structure */
  279.     vlc_mutex_init( p_dec, &p_spu->p_sys->lock );
  280.     p_spu->pf_render  = VCDSubBlend;
  281.     p_spu->pf_destroy = VCDSubDestroySPU;
  282.     p_spu->p_sys->p_data = (uint8_t*)p_spu->p_sys + sizeof( subpicture_sys_t );
  283.     p_spu->p_sys->i_x_end        = p_sys->i_x_start + p_sys->i_width - 1;
  284.     p_spu->p_sys->i_y_end        = p_sys->i_y_start + p_sys->i_height - 1;
  285.     p_spu->i_x        = p_sys->i_x_start 
  286.       + config_GetInt( p_dec, MODULE_STRING "-horizontal-correct" );
  287.     p_spu->p_sys->p_palette[0] = p_sys->p_palette[0];
  288.     p_spu->p_sys->p_palette[1] = p_sys->p_palette[1];
  289.     p_spu->p_sys->p_palette[2] = p_sys->p_palette[2];
  290.     p_spu->p_sys->p_palette[3] = p_sys->p_palette[3];
  291.     /* FIXME: use aspect ratio for x? */
  292.     p_spu->i_x        = (p_spu->i_x * 3) / 4; 
  293.     p_spu->i_y        = p_sys->i_y_start 
  294.       + config_GetInt( p_dec, MODULE_STRING "-vertical-correct" );
  295.     p_spu->i_width    = p_sys->i_width;
  296.     p_spu->i_height   = p_sys->i_height;
  297.     p_spu->i_start    = p_sys->i_pts;
  298.     p_spu->i_stop     = p_sys->i_pts + (p_sys->i_duration);
  299.     
  300.     p_spu->p_sys->b_crop  = VLC_FALSE;
  301.     p_spu->p_sys->i_debug = p_sys->i_debug;
  302.     /* Get display time now. If we do it later, we may miss the PTS. */
  303.     p_spu->p_sys->i_pts = p_sys->i_pts;
  304.     /* Attach to our input thread */
  305.     p_spu->p_sys->p_input = vlc_object_find( p_dec,
  306.                                              VLC_OBJECT_INPUT, FIND_PARENT );
  307.     /* We try to display it */
  308.     if( ParseImage( p_dec, p_spu ) )
  309.     {
  310.         /* There was a parse error, delete the subpicture */
  311.         spu_DestroySubpicture( p_sys->p_vout->p_spu, p_spu );
  312.         return;
  313.     }
  314.     /* SPU is finished - we can ask the video output to display it */
  315.     spu_DisplaySubpicture( p_sys->p_vout->p_spu, p_spu );
  316. }
  317. #define advance_color_byte_pointer
  318.   p++;
  319.   i_nibble_field = 2;
  320.   /*
  321.    * This is wrong, it may exceed maxp if it is the last, check
  322.    * should be moved to use location or the algorithm changed to
  323.    * that in vob2sub
  324.   */
  325.   if (p >= maxp) {
  326.     msg_Warn( p_dec,
  327.       "broken subtitle - overflow while decoding "
  328.       " padding (%d,%d,%d)n",
  329.       i_field, i_row, i_column );
  330.     return VLC_EGENERIC;
  331.   }
  332. #define CVD_FIELD_BITS (4)
  333. #define CVD_FIELD_MASK  ((1<<CVD_FIELD_BITS) - 1) 
  334. /* Get the next field - a 2-bit palette index and a run count.  To do
  335.    this we use byte image pointer p, and i_nibble_field which
  336.    indicates where we are in the byte.
  337. */
  338. static inline uint8_t
  339. ExtractField(uint8_t *p, uint8_t i_nibble_field) 
  340. {
  341.   return ( ( *p >> (CVD_FIELD_BITS*(i_nibble_field-1)) ) & CVD_FIELD_MASK );
  342. }
  343. /*****************************************************************************
  344.  * ParseImage: parse the image part of the subtitle
  345.  *****************************************************************************
  346.  This part parses the subtitle graphical data and stores it in a more
  347.  convenient structure for later rendering. 
  348.  Image data comes interlaced and is run-length encoded (RLE). Each
  349.  field is a four-bit nibbles that is further subdivided in a two-bit
  350.  repeat count and a two-bit color number - up to three pixels can be
  351.  described in four bits.  What a 0 repeat count means is unknown.  It
  352.  might be used for RLE extension.  There is a special case of a 0
  353.  repeat count though.  When the full nibble is zero, the rest of the
  354.  line is filled with the color value in the next nibble.  It is
  355.  unknown what happens if the color value is greater than three.  The
  356.  rest seems to use a 4-entries palette.  It is not impossible that the
  357.  fill-line complete case above is not as described and the zero repeat
  358.  count means fill line.  The sample code never produces this, so it
  359.  may be untested.
  360.  However we'll transform this so that that the RLE is expanded and
  361.  interlacing will also be removed. On output each pixel entry will by 
  362.  a 4-bit alpha (filling 8 bits), and 8-bit y, u, and v entry.
  363.  *****************************************************************************/
  364. static int 
  365. ParseImage( decoder_t *p_dec, subpicture_t * p_spu )
  366. {
  367.     decoder_sys_t *p_sys = p_dec->p_sys;
  368.     uint8_t i_field;       /* The subtitles are interlaced, are we on an
  369.       even or odd scanline?  */
  370.     unsigned int i_row;    /* scanline row number */
  371.     unsigned int i_column; /* scanline column number */
  372.     unsigned int i_width  = p_sys->i_width;
  373.     unsigned int i_height = p_sys->i_height;
  374.     uint8_t *p_dest = (uint8_t *)p_spu->p_sys->p_data;
  375.     uint8_t i_nibble_field;    /* The 2-bit pixels remaining in byte of *p.
  376.   Has value 0..2. */
  377.     vlc_bool_t b_filling;      /* Filling i_color to the of the line. */
  378.     uint8_t i_pending = 0;     /* number of pixels to fill with 
  379.   color zero 0..3 */
  380.     ogt_color_t i_color=0;     /* current pixel color: 0..3 */
  381.     uint8_t *p = p_sys->subtitle_data  + p_sys->i_image_offset;
  382.     uint8_t *maxp = p + p_sys->i_image_length;
  383.     dbg_print( (DECODE_DBG_CALL) , "width x height: %dx%d",
  384.        i_width, i_height);
  385.     if (p_sys && p_sys->i_debug & DECODE_DBG_IMAGE)
  386.       printf("n");
  387.     i_pending = 0;
  388.     for ( i_field=0; i_field < 2; i_field++ ) {
  389.       i_nibble_field = 2;  /* 4-bit pieces available in *p */
  390. #if 0
  391.       unsigned int i;
  392.       int8_t *b=p;
  393.       for (i=0; i< i_width * i_height; i++)
  394. printf ("%02x", b[i]);
  395.       printf("n");
  396. #endif
  397.     
  398.       for ( i_row=i_field; i_row < i_height; i_row += 2 ) {
  399. b_filling   = VLC_FALSE;
  400. for ( i_column=0; i_column<i_width; i_column++ ) {
  401.   if ( i_pending ) {
  402.     /* We are in the middle of a RLE expansion, just decrement and 
  403.        fall through with current color value */
  404.     i_pending--;
  405.   } else if ( b_filling ) {
  406.     /* We are just filling to the end of line with one color, just
  407.        reuse current color value */
  408.   } else {
  409.     uint8_t i_val = ExtractField(p, i_nibble_field--);
  410.     if ( i_nibble_field == 0 ) {
  411.       advance_color_byte_pointer;
  412.     }
  413.     if ( i_val == 0 ) {
  414.       /* fill the rest of the line with next color */
  415.       i_color = ExtractField( p, i_nibble_field-- );
  416.       if ( i_nibble_field == 0 ) {
  417. p++;
  418. i_nibble_field=2;
  419. /*
  420.   This is wrong, it may exceed maxp if it is the
  421.   last, check should be moved to use location or the
  422.   algorithm changed to that in vob2sub
  423. */
  424. if (p >= maxp) {
  425.   msg_Warn( p_dec, 
  426.     "broken subtitle - overflow while decoding "
  427.     " filling (%d,%d,%d)", 
  428.       i_field, i_row, i_column);
  429.   /* return VLC_EGENERIC; */
  430. }
  431.       }
  432.       b_filling = VLC_TRUE;
  433.     } else {
  434.       /* Normal case: get color and repeat count, 
  435.  this iteration will  output the first (or only) 
  436.  instance */
  437.       i_pending = (i_val >> 2);
  438.       i_color = i_val & 0x3;
  439.       /* This time counts against the total */
  440.       i_pending--;
  441.     }
  442.   }
  443.   /* Color is 0-3. */
  444.   p_dest[i_row*i_width+i_column] = i_color;
  445.   
  446.   if (p_sys && p_sys->i_debug & DECODE_DBG_IMAGE)
  447.     printf("%1d", i_color);
  448.   
  449. }
  450. if ( i_nibble_field == 1 ) {
  451.   advance_color_byte_pointer;
  452. }
  453. if (p_sys && p_sys->i_debug & DECODE_DBG_IMAGE)
  454.   printf("n");
  455.       }
  456.     }
  457.     if (p_sys && (p_sys->i_debug & DECODE_DBG_IMAGE)) {
  458.       /* Dump out image not interlaced... */
  459.       VCDSubDumpImage( p_dest, i_height, i_width );
  460.     }
  461. #ifdef HAVE_LIBPNG
  462.     if (p_sys && (p_sys->i_debug & DECODE_DBG_PNG)) {
  463. #define TEXT_COUNT 2
  464.       /* Dump image to a file in PNG format. */
  465.       char filename[300];
  466.       png_text text_ptr[TEXT_COUNT];
  467.       text_ptr[0].key = "Preparer";
  468.       text_ptr[0].text = "VLC";
  469.       text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE;
  470.       text_ptr[1].key = "Description";
  471.       text_ptr[1].text = "CVD Subtitle";
  472.       text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE;
  473.       snprintf(filename, 300, "%s%d.png", "/tmp/vlc-cvd-sub", p_sys->i_image);
  474.       VCDSubDumpPNG( p_dest, p_dec, i_height, i_width, filename,
  475.      text_ptr, TEXT_COUNT );
  476.     }
  477. #endif /*HAVE_LIBPNG*/
  478.     VCDSubHandleScaling( p_spu, p_dec );
  479.     return VLC_SUCCESS;
  480. }