解决 PGS 字幕无法解码与渲染的问题

1
2
3
4
5
6
7
8

typedef struct AVSubtitle {
    uint16_t format; /* 0 = graphics */
    uint32_t start_display_time; /* relative to packet pts, in ms */
    uint32_t end_display_time; /* relative to packet pts, in ms */
    unsigned num_rects;
    AVSubtitleRect **rects;
    int64_t pts;    ///< Same as packet pts, in AV_TIME_BASE
} AVSubtitle;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

typedef struct AVSubtitleRect {
    int x;         ///< top left corner  of pict, undefined when pict is not set
    int y;         ///< top left corner  of pict, undefined when pict is not set
    int w;         ///< width            of pict, undefined when pict is not set
    int h;         ///< height           of pict, undefined when pict is not set
    int nb_colors; ///< number of colors in pict, undefined when pict is not set

#if FF_API_AVPICTURE
    /**
     * @deprecated unused
     */
    attribute_deprecated
    AVPicture pict;
#endif
    /**
     * data+linesize for the bitmap of this subtitle.
     * Can be set for text/ass as well once they are rendered.
     */
    uint8_t *data[4];
    int linesize[4];

    enum AVSubtitleType type;

    char *text;                     ///< 0 terminated plain UTF-8 text

    /**
     * 0 terminated ASS/SSA compatible event line.
     * The presentation of this is unaffected by the other values in this
     * struct.
     */
    char *ass;

    int flags;
} AVSubtitleRect;

1
2
3
4
5
6

    /**
     * data+linesize for the bitmap of this subtitle.
     * Can be set for text/ass as well once they are rendered.
     */
    uint8_t *data[4];
    int linesize[4];

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

/**
 * Picture data structure.
 *
 * Up to four components can be stored into it, the last component is
 * alpha.
 * @deprecated use AVFrame or imgutils functions instead
 */
typedef struct AVPicture {
    attribute_deprecated
    uint8_t *data[AV_NUM_DATA_POINTERS];    ///< pointers to the image data planes
    attribute_deprecated
    int linesize[AV_NUM_DATA_POINTERS];     ///< number of bytes per line
} AVPicture;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

sub_header->rects = av_mallocz(sizeof(*sub_header->rects));
if (!sub_header->rects)
  goto fail;
sub_header->rects[0] = av_mallocz(sizeof(AVSubtitleRect));
if (!sub_header->rects[0])
  goto fail;
sub_header->num_rects = 1;
bitmap = sub_header->rects[0]->data[0] = av_malloc(w * h);
if (!bitmap)
  goto fail;
if (decode_rle(bitmap, w * 2, w, (h + 1) / 2,
               buf, offset1, buf_size, is_8bit) < 0)
  goto fail;
if (decode_rle(bitmap + w, w * 2, w, h / 2,
               buf, offset2, buf_size, is_8bit) < 0)
  goto fail;
sub_header->rects[0]->data[1] = av_mallocz(AVPALETTE_SIZE);
if (!sub_header->rects[0]->data[1])
  goto fail;
if (is_8bit) {
  if (!yuv_palette)
    goto fail;
  sub_header->rects[0]->nb_colors = 256;
  yuv_a_to_rgba(yuv_palette, alpha,
                (uint32_t *)sub_header->rects[0]->data[1],
                256);
} else {
  sub_header->rects[0]->nb_colors = 4;
  guess_palette(ctx, (uint32_t*)sub_header->rects[0]->data[1],
                0xffff00);
}

1
2
3

yuv_a_to_rgba(yuv_palette, alpha,
                (uint32_t *)sub_header->rects[0]->data[1],
                256);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

/**
 * Decode the RLE data.
 *
 * The subtitle is stored as a Run Length Encoded image.
 *
 * @param avctx contains the current codec context
 * @param sub pointer to the processed subtitle data
 * @param buf pointer to the RLE data to process
 * @param buf_size size of the RLE data to process
 */
static int decode_rle(AVCodecContext *avctx, AVSubtitleRect *rect,
                      const uint8_t *buf, unsigned int buf_size)

1
2
3
4

/*
CoreVideo pixel format type constants.
CoreVideo does not provide support for all of these formats; this list just defines their names.
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

/**
 * Pixel format.
 *
 * @note
 * AV_PIX_FMT_RGB32 is handled in an endian-specific manner. An RGBA
 * color is put together as:
 *  (A << 24) | (R << 16) | (G << 8) | B
 * This is stored as BGRA on little-endian CPU architectures and ARGB on
 * big-endian CPUs.
 *
 * @note
 * If the resolution is not a multiple of the chroma subsampling factor
 * then the chroma plane resolution must be rounded up.
 *
 * @par
 * When the pixel format is palettized RGB32 (AV_PIX_FMT_PAL8), the palettized
 * image data is stored in AVFrame.data[0]. The palette is transported in
 * AVFrame.data[1], is 1024 bytes long (256 4-byte entries) and is
 * formatted the same as in AV_PIX_FMT_RGB32 described above (i.e., it is
 * also endian-specific). Note also that the individual RGB32 palette
 * components stored in AVFrame.data[1] should be in the range 0..255.
 * This is important as many custom PAL8 video codecs that were designed
 * to run on the IBM VGA graphics adapter use 6-bit palette components.
 *
 * @par
 * For all the 8 bits per pixel formats, an RGB32 palette is in data[1] like
 * for pal8. This palette is filled in automatically by the function
 * allocating the picture.
 */

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

static uint32_t* copy_pal8_to_bgra(const AVSubtitleRect* rect)
{
    size_t size = rect->w * rect->h * 4; /* times 4 because 4 bytes per pixel */
    uint32_t colours[256];
    uint32_t *buff = NULL;
    
    buff = av_malloc(size);
    if (buff == NULL) {
        ALOGE("Error allocating memory for subtitle bitmap.\n");
        return NULL;
    }
    
    for (int i = 0; i < 256; ++i) {
        /* Colour conversion. */
        int idx = i * 4; /* again, 4 bytes per pixel */
        uint8_t r = rect->data[1][idx],
        g = rect->data[1][idx + 1],
        b = rect->data[1][idx + 2],
        a = rect->data[1][idx + 3];
        colours[i] = (b << 24) | (g << 16) | (r << 8) | a;
    }
    
    for (int y = 0; y < rect->h; ++y) {
        for (int x = 0; x < rect->w; ++x) {
            /* 1 byte per pixel */
            int coordinate = x + y * rect->linesize[0];
            /* 32bpp color table */
            int idx = rect->data[0][coordinate];
            buff[x + (y * rect->w)] = colours[idx];
        }
    }
    
    return buff;
}

1

CVPixelBufferCreateWithBytes(kCFAllocatorDefault, pict->w, pict->h, kCVPixelFormatType_32BGRA, pict->data, pict->w * 4, NULL, NULL, (__bridge CFDictionaryRef)options, &pixelBuffer);

1
2
3
4
5
6

IOSurfaceRef surface = CVPixelBufferGetIOSurface(pixel_buffer);

if (!surface) {
  printf("CVPixelBuffer has no IOSurface\n");
  return GL_FALSE;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

CVPixelBufferRef pixelBuffer = NULL;
NSDictionary *options = @{
  (__bridge NSString*)kCVPixelBufferOpenGLCompatibilityKey : @YES,
  (__bridge NSString*)kCVPixelBufferIOSurfacePropertiesKey : [NSDictionary dictionary]
};

CVReturn ret = CVPixelBufferCreate(kCFAllocatorDefault, pict->w, pict->h, kCVPixelFormatType_32BGRA, (__bridge CFDictionaryRef)options, &pixelBuffer);

NSParameterAssert(ret == kCVReturnSuccess && pixelBuffer != NULL);

CVPixelBufferLockBaseAddress(pixelBuffer, 0);

uint8_t *baseAddress = CVPixelBufferGetBaseAddress(pixelBuffer);
int linesize = (int)CVPixelBufferGetBytesPerRow(pixelBuffer);

uint8_t *dst_data[4] = {baseAddress,NULL,NULL,NULL};
int dst_linesizes[4] = {linesize,0,0,0};

const uint8_t *src_data[4] = {pict->pixels,NULL,NULL,NULL};
const int src_linesizes[4] = {pict->linesize,0,0,0};

av_image_copy(dst_data, dst_linesizes, src_data, src_linesizes, AV_PIX_FMT_BGRA, pict->w, pict->h);

CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);