hvirtual/libmpeg3/video/subtitle.c

Go to the documentation of this file.

#include "mpeg3private.h"
#include "mpeg3protos.h"

#include <stdlib.h>

static unsigned char get_nibble(unsigned char **ptr, int *nibble)
{
        if(*nibble)
        {
                *nibble = !*nibble;
                return (*(*ptr)++) & 0xf;
        }
        else
        {
                *nibble = !*nibble;
                return (*(*ptr)) >> 4;
        }
}

/* Returns 1 if failure */
/* This is largely from spudec, ffmpeg */
int decompress_subtitle(mpeg3_t *file, mpeg3_subtitle_t *subtitle)
{
        int i;
        unsigned char *ptr = subtitle->data;
        unsigned char *end = subtitle->data + subtitle->size;
        int even_offset = 0;
        int odd_offset = 0;

/* packet size */
        ptr += 2;

/* data packet size */
        if(ptr + 2 > end) return 1;

        int data_size = (*ptr++) << 8;
        data_size |= *ptr++;

        unsigned char *data_start = ptr;
        if(ptr + data_size > end) return 1;

/* Advance to control sequences */
        ptr += data_size - 2;

        subtitle->palette[0] = 0x00;
        subtitle->palette[1] = 0x01;
        subtitle->palette[2] = 0x02;
        subtitle->palette[3] = 0x03;

        subtitle->alpha[0] = 0xff;
        subtitle->alpha[1] = 0x00;
        subtitle->alpha[2] = 0x40;
        subtitle->alpha[3] = 0xc0;

/* Control sequence */
        unsigned char *control_start = 0;
        unsigned char *next_control_start = ptr;
        int got_alpha = 0;
        while(ptr < end && control_start != next_control_start)
        {
                control_start = next_control_start;

/* Date */
                if(ptr + 2 > end) break;
                int date = (*ptr++) << 8;
                date |= *ptr++;

/* Offset of next control sequence */
                if(ptr + 2 > end) break;
                int next = (*ptr++) << 8;
                next |= *ptr++;

                next_control_start = subtitle->data + next;

                int done = 0;
                while(ptr < end && !done)
                {
                        int type = *ptr++;

                        switch(type)
                        {
                                case 0x00:
                                        subtitle->force = 1;
                                        break;

                                case 0x01:
                                        subtitle->start_time = date;
//printf("decompress_subtitle %d\n", subtitle->start_time);
                                        break;

                                case 0x02:
                                        subtitle->stop_time = date;
                                        break;

                                case 0x03:
/* Entry in palette of each color */
                                        if(ptr + 4 > end) return 1;
                                        subtitle->palette[0] = (*ptr) >> 4;
                                        subtitle->palette[1] = (*ptr++) & 0xf;
                                        subtitle->palette[2] = (*ptr) >> 4;
                                        subtitle->palette[3] = (*ptr++) & 0xf;
//printf("subtitle palette %d %d %d %d\n", subtitle->palette[0], subtitle->palette[1], subtitle->palette[2], subtitle->palette[3]);
                                        break;

                                case 0x04:
/* Alpha corresponding to each color */
                                        if(ptr + 4 > end) return 1;
                                        subtitle->alpha[0] = ((*ptr) >> 4) * 255 / 15;
                                        subtitle->alpha[1] = ((*ptr) & 0xf) * 255 / 15;
                                        subtitle->alpha[2] = ((*ptr++) >> 4) * 255 / 15;
                                        subtitle->alpha[3] = ((*ptr++) & 0xf) * 255 / 15;
                                        got_alpha = 1;
//printf("subtitle alpha %d %d %d %d\n", subtitle->alpha[0], subtitle->alpha[1], subtitle->alpha[2], subtitle->alpha[3]);
                                        break;

                                case 0x05:
/* Extent of image on screen */
                                        if(ptr + 6 > end) return 1;
/*
 * printf("decompress_subtitle 10 %02x %02x %02x %02x %02x %02x\n",
 * ptr[0],
 * ptr[1],
 * ptr[2],
 * ptr[3],
 * ptr[4],
 * ptr[5]);
 */
                                        subtitle->x1 = (*ptr++) << 4;
                                        subtitle->x1 |= (*ptr) >> 4;
                                        subtitle->x2 = ((*ptr++) & 0xf) << 8;
                                        subtitle->x2 |= *ptr++;
                                        subtitle->y1 = (*ptr++) << 4;
                                        subtitle->y1 |= (*ptr) >> 4;
                                        subtitle->y2 = ((*ptr++) & 0xf) << 8;
                                        subtitle->y2 |= *ptr++;
                                        subtitle->x2++;
                                        subtitle->y2++;
                                        subtitle->w = subtitle->x2 - subtitle->x1;
                                        subtitle->h = subtitle->y2 - subtitle->y1;
/*
 * printf("decompress_subtitle 20 x1=%d x2=%d y1=%d y2=%d\n", 
 * subtitle->x1, 
 * subtitle->x2, 
 * subtitle->y1, 
 * subtitle->y2);
 */
                                        CLAMP(subtitle->w, 1, 2048);
                                        CLAMP(subtitle->h, 1, 2048);
                                        CLAMP(subtitle->x1, 0, 2048);
                                        CLAMP(subtitle->x2, 0, 2048);
                                        CLAMP(subtitle->y1, 0, 2048);
                                        CLAMP(subtitle->y2, 0, 2048);
                                        break;

                                case 0x06:
/* offsets of even and odd field in compressed data */
                                        if(ptr + 4 > end) return 1;
                                        even_offset = (ptr[0] << 8) | (ptr[1]);
                                        odd_offset = (ptr[2] << 8) | (ptr[3]);
//printf("decompress_subtitle 30 even=0x%x odd=0x%x\n", even_offset, odd_offset);
                                        ptr += 4;
                                        break;

                                case 0xff:
                                        done = 1;
                                        break;

                                default:
//                                      printf("unknown type %02x\n", type);
                                        break;
                        }
                }

        }



/* Allocate image buffer */
        subtitle->image_y = (unsigned char*)calloc(1, subtitle->w * subtitle->h + subtitle->w);
        subtitle->image_u = (unsigned char*)calloc(1, subtitle->w * subtitle->h / 4 + subtitle->w);
        subtitle->image_v = (unsigned char*)calloc(1, subtitle->w * subtitle->h / 4 + subtitle->w);
        subtitle->image_a = (unsigned char*)calloc(1, subtitle->w * subtitle->h + subtitle->w);

/* Decode image */
        int current_nibble = 0;
        int x = 0, y = 0, field = 0;
        ptr = data_start;
        int first_pixel = 1;

        while(ptr < end && y < subtitle->h + 1 && x < subtitle->w)
        {
// Start new field based on offset, not total lines
                if(ptr - data_start >= odd_offset - 4 && 
                        field == 0)
                {
                        field = 1;
                        y = 1;
                        x = 0;

                        if(current_nibble)
                        {
                                ptr++;
                                current_nibble = 0;
                        }
                }


                unsigned int code = get_nibble(&ptr, &current_nibble);
                if(code < 0x4 && ptr < end)
                {
                        code = (code << 4) | get_nibble(&ptr, &current_nibble);
                        if(code < 0x10 && ptr < end)
                        {
                                code = (code << 4) | get_nibble(&ptr, &current_nibble);
                                if(code < 0x40 && ptr < end)
                                {
                                        code = (code << 4) | get_nibble(&ptr, &current_nibble);
/* carriage return */
                                        if(code < 0x4 && ptr < end)
                                                code |= (subtitle->w - x) << 2;
                                }
                        }
                }

                int color = (code & 0x3);
                int len = code >> 2;
                if(len > subtitle->w - x)
                        len = subtitle->w - x;

                int y_color = file->palette[subtitle->palette[color] * 4];
                int u_color = file->palette[subtitle->palette[color] * 4 + 1];
                int v_color = file->palette[subtitle->palette[color] * 4 + 2];
                int a_color = subtitle->alpha[color];

// The alpha seems to be arbitrary.  Assume the top left pixel is always 
// transparent.
                if(first_pixel)
                {
                        subtitle->alpha[color] = 0x0;
                        a_color = 0x0;
                        first_pixel = 0;
                }

/*
 * printf("0x%02x 0x%02x 0x%02x\n", 
 * y_color,
 * u_color,
 * v_color);
 */
                if(y < subtitle->h)
                {
                        for(i = 0; i < len; i++)
                        {
                                subtitle->image_y[y * subtitle->w + x] = y_color;
                                if(!(x % 2) && !(y % 2))
                                {
                                        subtitle->image_u[y / 2 * subtitle->w / 2 + x / 2] = u_color;
                                        subtitle->image_v[y / 2 * subtitle->w / 2 + x / 2] = v_color;
                                }
                                subtitle->image_a[y * subtitle->w + x] = a_color;
                                x++;
                        }
                }

                if(x >= subtitle->w)
                {
                        x = 0;
                        y += 2;

/* Byte alignment */
                        if(current_nibble)
                        {
                                ptr++;
                                current_nibble = 0;
                        }

// Start new field based on total lines, not offset
                        if(y >= subtitle->h)
                        {
                                y = subtitle->h - 1;
/*
 *                              if(!field)
 *                              {
 *                                      y = 1;
 *                                      field = 1;
 *                              }
 */
                        }
                }
        }

/*
 * printf("decompress_subtitle coords: %d,%d - %d,%d size: %d,%d start_time=%d end_time=%d\n", 
 * subtitle->x1, 
 * subtitle->y1, 
 * subtitle->x2, 
 * subtitle->y2,
 * subtitle->w,
 * subtitle->h,
 * subtitle->start_time,
 * subtitle->stop_time);
 */
        return 0;
}




void overlay_subtitle(mpeg3video_t *video, mpeg3_subtitle_t *subtitle)
{
        int x, y;
        for(y = subtitle->y1; 
                y < subtitle->y2 && y < video->coded_picture_height; 
                y++)
        {
                unsigned char *output_y = video->subtitle_frame[0] + 
                        y * video->coded_picture_width +
                        subtitle->x1;
                unsigned char *output_u = video->subtitle_frame[1] + 
                        y / 2 * video->chrom_width +
                        subtitle->x1 / 2;
                unsigned char *output_v = video->subtitle_frame[2] + 
                        y / 2 * video->chrom_width +
                        subtitle->x1 / 2;
                unsigned char *input_y = subtitle->image_y + (y - subtitle->y1) * subtitle->w;
                unsigned char *input_u = subtitle->image_u + (y - subtitle->y1) / 2 * subtitle->w / 2;
                unsigned char *input_v = subtitle->image_v + (y - subtitle->y1) / 2 * subtitle->w / 2;
                unsigned char *input_a = subtitle->image_a + (y - subtitle->y1) * subtitle->w;

                for(x = subtitle->x1; 
                        x < subtitle->x2 && x < video->coded_picture_width; 
                        x++)
                {
                        int opacity = *input_a;
                        int transparency = 0xff - opacity;
                        *output_y = (*input_y * opacity + *output_y * transparency) / 0xff;

                        if(!(y % 2) && !(x % 2))
                        {
                                *output_u = (*input_u * opacity + *output_u * transparency) / 0xff;
                                *output_v = (*input_v * opacity + *output_v * transparency) / 0xff;
                                output_u++;
                                output_v++;
                                input_u++;
                                input_v++;
                        }

                        output_y++;
                        input_y++;
                        input_a++;
                }
        }
}



void mpeg3_decode_subtitle(mpeg3video_t *video)
{
/* Test demuxer for subtitle */
        mpeg3_vtrack_t *vtrack  = (mpeg3_vtrack_t*)video->track;
        mpeg3_t *file = (mpeg3_t*)video->file;

/* Clear subtitles from inactive subtitle tracks */
        int i;
        for(i = 0; i < mpeg3_subtitle_tracks(file); i++)
        {
                if(i != file->subtitle_track)
                        mpeg3_pop_all_subtitles(mpeg3_get_strack(file, i));
        }

        if(file->subtitle_track >= 0 &&
                file->subtitle_track < mpeg3_subtitle_tracks(file))
        {
                mpeg3_strack_t *strack = mpeg3_get_strack(file, file->subtitle_track);
                int total = 0;
                if(strack)
                {
                        for(i = 0; i < strack->total_subtitles; i++)
                        {
                                mpeg3_subtitle_t *subtitle = strack->subtitles[i];
                                if(!subtitle->active)
                                {
/* Exclude object from future activation */
                                        subtitle->active = 1;

/* Decompress subtitle */
                                        if(decompress_subtitle(file, subtitle))
                                        {
/* Remove subtitle if failed */
                                                mpeg3_pop_subtitle(strack, i, 1);
                                                i--;
                                                continue;
                                        }
                                }



/* Test start and end time of subtitle */
                                if(subtitle->stop_time > 0)
                                {
/* Copy video to temporary */
                                        if(!total)
                                        {
                                                if(!video->subtitle_frame[0])
                                                {
                                                        video->subtitle_frame[0] = malloc(
                                                                video->coded_picture_width * 
                                                                video->coded_picture_height + 8);
                                                        video->subtitle_frame[1] = malloc(
                                                                video->chrom_width * 
                                                                video->chrom_height + 8);
                                                        video->subtitle_frame[2] = malloc(
                                                                video->chrom_width * 
                                                                video->chrom_height + 8);
                                                }

                                                memcpy(video->subtitle_frame[0],
                                                        video->output_src[0],
                                                        video->coded_picture_width * video->coded_picture_height);
                                                memcpy(video->subtitle_frame[1],
                                                        video->output_src[1],
                                                        video->chrom_width * video->chrom_height);
                                                memcpy(video->subtitle_frame[2],
                                                        video->output_src[2],
                                                        video->chrom_width * video->chrom_height);

                                                video->output_src[0] = video->subtitle_frame[0];
                                                video->output_src[1] = video->subtitle_frame[1];
                                                video->output_src[2] = video->subtitle_frame[2];
                                        }
                                        total++;


/* Overlay subtitle on video */
                                        overlay_subtitle(video, subtitle);
                                        subtitle->stop_time -= (int)(100.0 / video->frame_rate);
                                }

                                if(subtitle->stop_time <= 0)
                                {
                                        mpeg3_pop_subtitle(strack, i, 1);
                                        i--;
                                }
                        }
                }
        }




}

---