FFmpeg
pgssubdec.c
Go to the documentation of this file.
1 /*
2  * PGS subtitle decoder
3  * Copyright (c) 2009 Stephen Backway
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * PGS subtitle decoder
25  */
26 
27 #include "avcodec.h"
28 #include "bytestream.h"
29 #include "internal.h"
30 #include "mathops.h"
31 
32 #include "libavutil/colorspace.h"
33 #include "libavutil/imgutils.h"
34 #include "libavutil/opt.h"
35 
36 #define RGBA(r,g,b,a) (((unsigned)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))
37 #define MAX_EPOCH_PALETTES 8 // Max 8 allowed per PGS epoch
38 #define MAX_EPOCH_OBJECTS 64 // Max 64 allowed per PGS epoch
39 #define MAX_OBJECT_REFS 2 // Max objects per display set
40 
47 };
48 
49 typedef struct PGSSubObjectRef {
50  int id;
51  int window_id;
53  int x;
54  int y;
55  int crop_x;
56  int crop_y;
57  int crop_w;
58  int crop_h;
60 
61 typedef struct PGSSubPresentation {
62  int id_number;
66  int64_t pts;
68 
69 typedef struct PGSSubObject {
70  int id;
71  int w;
72  int h;
74  unsigned int rle_buffer_size, rle_data_len;
75  unsigned int rle_remaining_len;
76 } PGSSubObject;
77 
78 typedef struct PGSSubObjects {
79  int count;
82 
83 typedef struct PGSSubPalette {
84  int id;
85  uint32_t clut[256];
87 
88 typedef struct PGSSubPalettes {
89  int count;
92 
93 typedef struct PGSSubContext {
94  AVClass *class;
100 
101 static void flush_cache(AVCodecContext *avctx)
102 {
103  PGSSubContext *ctx = avctx->priv_data;
104  int i;
105 
106  for (i = 0; i < ctx->objects.count; i++) {
107  av_freep(&ctx->objects.object[i].rle);
108  ctx->objects.object[i].rle_buffer_size = 0;
109  ctx->objects.object[i].rle_remaining_len = 0;
110  }
111  ctx->objects.count = 0;
112  ctx->palettes.count = 0;
113 }
114 
115 static PGSSubObject * find_object(int id, PGSSubObjects *objects)
116 {
117  int i;
118 
119  for (i = 0; i < objects->count; i++) {
120  if (objects->object[i].id == id)
121  return &objects->object[i];
122  }
123  return NULL;
124 }
125 
126 static PGSSubPalette * find_palette(int id, PGSSubPalettes *palettes)
127 {
128  int i;
129 
130  for (i = 0; i < palettes->count; i++) {
131  if (palettes->palette[i].id == id)
132  return &palettes->palette[i];
133  }
134  return NULL;
135 }
136 
138 {
139  avctx->pix_fmt = AV_PIX_FMT_PAL8;
140 
141  return 0;
142 }
143 
145 {
146  flush_cache(avctx);
147 
148  return 0;
149 }
150 
151 /**
152  * Decode the RLE data.
153  *
154  * The subtitle is stored as a Run Length Encoded image.
155  *
156  * @param avctx contains the current codec context
157  * @param sub pointer to the processed subtitle data
158  * @param buf pointer to the RLE data to process
159  * @param buf_size size of the RLE data to process
160  */
162  const uint8_t *buf, unsigned int buf_size)
163 {
164  const uint8_t *rle_bitmap_end;
165  int pixel_count, line_count;
166 
167  rle_bitmap_end = buf + buf_size;
168 
169  rect->data[0] = av_malloc_array(rect->w, rect->h);
170 
171  if (!rect->data[0])
172  return AVERROR(ENOMEM);
173 
174  pixel_count = 0;
175  line_count = 0;
176 
177  while (buf < rle_bitmap_end && line_count < rect->h) {
179  int run;
180 
181  color = bytestream_get_byte(&buf);
182  run = 1;
183 
184  if (color == 0x00) {
185  flags = bytestream_get_byte(&buf);
186  run = flags & 0x3f;
187  if (flags & 0x40)
188  run = (run << 8) + bytestream_get_byte(&buf);
189  color = flags & 0x80 ? bytestream_get_byte(&buf) : 0;
190  }
191 
192  if (run > 0 && pixel_count + run <= rect->w * rect->h) {
193  memset(rect->data[0] + pixel_count, color, run);
194  pixel_count += run;
195  } else if (!run) {
196  /*
197  * New Line. Check if correct pixels decoded, if not display warning
198  * and adjust bitmap pointer to correct new line position.
199  */
200  if (pixel_count % rect->w > 0) {
201  av_log(avctx, AV_LOG_ERROR, "Decoded %d pixels, when line should be %d pixels\n",
202  pixel_count % rect->w, rect->w);
203  if (avctx->err_recognition & AV_EF_EXPLODE) {
204  return AVERROR_INVALIDDATA;
205  }
206  }
207  line_count++;
208  }
209  }
210 
211  if (pixel_count < rect->w * rect->h) {
212  av_log(avctx, AV_LOG_ERROR, "Insufficient RLE data for subtitle\n");
213  return AVERROR_INVALIDDATA;
214  }
215 
216  ff_dlog(avctx, "Pixel Count = %d, Area = %d\n", pixel_count, rect->w * rect->h);
217 
218  return 0;
219 }
220 
221 /**
222  * Parse the picture segment packet.
223  *
224  * The picture segment contains details on the sequence id,
225  * width, height and Run Length Encoded (RLE) bitmap data.
226  *
227  * @param avctx contains the current codec context
228  * @param buf pointer to the packet to process
229  * @param buf_size size of packet to process
230  */
232  const uint8_t *buf, int buf_size)
233 {
234  PGSSubContext *ctx = avctx->priv_data;
235  PGSSubObject *object;
236 
237  uint8_t sequence_desc;
238  unsigned int rle_bitmap_len, width, height;
239  int id;
240 
241  if (buf_size <= 4)
242  return AVERROR_INVALIDDATA;
243  buf_size -= 4;
244 
245  id = bytestream_get_be16(&buf);
246  object = find_object(id, &ctx->objects);
247  if (!object) {
248  if (ctx->objects.count >= MAX_EPOCH_OBJECTS) {
249  av_log(avctx, AV_LOG_ERROR, "Too many objects in epoch\n");
250  return AVERROR_INVALIDDATA;
251  }
252  object = &ctx->objects.object[ctx->objects.count++];
253  object->id = id;
254  }
255 
256  /* skip object version number */
257  buf += 1;
258 
259  /* Read the Sequence Description to determine if start of RLE data or appended to previous RLE */
260  sequence_desc = bytestream_get_byte(&buf);
261 
262  if (!(sequence_desc & 0x80)) {
263  /* Additional RLE data */
264  if (buf_size > object->rle_remaining_len)
265  return AVERROR_INVALIDDATA;
266 
267  memcpy(object->rle + object->rle_data_len, buf, buf_size);
268  object->rle_data_len += buf_size;
269  object->rle_remaining_len -= buf_size;
270 
271  return 0;
272  }
273 
274  if (buf_size <= 7)
275  return AVERROR_INVALIDDATA;
276  buf_size -= 7;
277 
278  /* Decode rle bitmap length, stored size includes width/height data */
279  rle_bitmap_len = bytestream_get_be24(&buf) - 2*2;
280 
281  if (buf_size > rle_bitmap_len) {
282  av_log(avctx, AV_LOG_ERROR,
283  "Buffer dimension %d larger than the expected RLE data %d\n",
284  buf_size, rle_bitmap_len);
285  return AVERROR_INVALIDDATA;
286  }
287 
288  /* Get bitmap dimensions from data */
289  width = bytestream_get_be16(&buf);
290  height = bytestream_get_be16(&buf);
291 
292  /* Make sure the bitmap is not too large */
293  if (avctx->width < width || avctx->height < height || !width || !height) {
294  av_log(avctx, AV_LOG_ERROR, "Bitmap dimensions (%dx%d) invalid.\n", width, height);
295  return AVERROR_INVALIDDATA;
296  }
297 
298  object->w = width;
299  object->h = height;
300 
301  av_fast_padded_malloc(&object->rle, &object->rle_buffer_size, rle_bitmap_len);
302 
303  if (!object->rle) {
304  object->rle_data_len = 0;
305  object->rle_remaining_len = 0;
306  return AVERROR(ENOMEM);
307  }
308 
309  memcpy(object->rle, buf, buf_size);
310  object->rle_data_len = buf_size;
311  object->rle_remaining_len = rle_bitmap_len - buf_size;
312 
313  return 0;
314 }
315 
316 /**
317  * Parse the palette segment packet.
318  *
319  * The palette segment contains details of the palette,
320  * a maximum of 256 colors can be defined.
321  *
322  * @param avctx contains the current codec context
323  * @param buf pointer to the packet to process
324  * @param buf_size size of packet to process
325  */
327  const uint8_t *buf, int buf_size)
328 {
329  PGSSubContext *ctx = avctx->priv_data;
330  PGSSubPalette *palette;
331 
332  const uint8_t *buf_end = buf + buf_size;
333  const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;
334  int color_id;
335  int y, cb, cr, alpha;
336  int r, g, b, r_add, g_add, b_add;
337  int id;
338 
339  id = bytestream_get_byte(&buf);
340  palette = find_palette(id, &ctx->palettes);
341  if (!palette) {
342  if (ctx->palettes.count >= MAX_EPOCH_PALETTES) {
343  av_log(avctx, AV_LOG_ERROR, "Too many palettes in epoch\n");
344  return AVERROR_INVALIDDATA;
345  }
346  palette = &ctx->palettes.palette[ctx->palettes.count++];
347  palette->id = id;
348  }
349 
350  /* Skip palette version */
351  buf += 1;
352 
353  while (buf < buf_end) {
354  color_id = bytestream_get_byte(&buf);
355  y = bytestream_get_byte(&buf);
356  cr = bytestream_get_byte(&buf);
357  cb = bytestream_get_byte(&buf);
358  alpha = bytestream_get_byte(&buf);
359 
360  /* Default to BT.709 colorspace. In case of <= 576 height use BT.601 */
361  if (avctx->height <= 0 || avctx->height > 576) {
362  YUV_TO_RGB1_CCIR_BT709(cb, cr);
363  } else {
364  YUV_TO_RGB1_CCIR(cb, cr);
365  }
366 
367  YUV_TO_RGB2_CCIR(r, g, b, y);
368 
369  ff_dlog(avctx, "Color %d := (%d,%d,%d,%d)\n", color_id, r, g, b, alpha);
370 
371  /* Store color in palette */
372  palette->clut[color_id] = RGBA(r,g,b,alpha);
373  }
374  return 0;
375 }
376 
377 /**
378  * Parse the presentation segment packet.
379  *
380  * The presentation segment contains details on the video
381  * width, video height, x & y subtitle position.
382  *
383  * @param avctx contains the current codec context
384  * @param buf pointer to the packet to process
385  * @param buf_size size of packet to process
386  * @todo TODO: Implement cropping
387  */
389  const uint8_t *buf, int buf_size,
390  int64_t pts)
391 {
392  PGSSubContext *ctx = avctx->priv_data;
393  int i, state, ret;
394  const uint8_t *buf_end = buf + buf_size;
395 
396  // Video descriptor
397  int w = bytestream_get_be16(&buf);
398  int h = bytestream_get_be16(&buf);
399 
400  ctx->presentation.pts = pts;
401 
402  ff_dlog(avctx, "Video Dimensions %dx%d\n",
403  w, h);
404  ret = ff_set_dimensions(avctx, w, h);
405  if (ret < 0)
406  return ret;
407 
408  /* Skip 1 bytes of unknown, frame rate */
409  buf++;
410 
411  // Composition descriptor
412  ctx->presentation.id_number = bytestream_get_be16(&buf);
413  /*
414  * state is a 2 bit field that defines pgs epoch boundaries
415  * 00 - Normal, previously defined objects and palettes are still valid
416  * 01 - Acquisition point, previous objects and palettes can be released
417  * 10 - Epoch start, previous objects and palettes can be released
418  * 11 - Epoch continue, previous objects and palettes can be released
419  *
420  * reserved 6 bits discarded
421  */
422  state = bytestream_get_byte(&buf) >> 6;
423  if (state != 0) {
424  flush_cache(avctx);
425  }
426 
427  /*
428  * skip palette_update_flag (0x80),
429  */
430  buf += 1;
431  ctx->presentation.palette_id = bytestream_get_byte(&buf);
432  ctx->presentation.object_count = bytestream_get_byte(&buf);
434  av_log(avctx, AV_LOG_ERROR,
435  "Invalid number of presentation objects %d\n",
437  ctx->presentation.object_count = 2;
438  if (avctx->err_recognition & AV_EF_EXPLODE) {
439  return AVERROR_INVALIDDATA;
440  }
441  }
442 
443 
444  for (i = 0; i < ctx->presentation.object_count; i++)
445  {
446 
447  if (buf_end - buf < 8) {
448  av_log(avctx, AV_LOG_ERROR, "Insufficent space for object\n");
449  ctx->presentation.object_count = i;
450  return AVERROR_INVALIDDATA;
451  }
452 
453  ctx->presentation.objects[i].id = bytestream_get_be16(&buf);
454  ctx->presentation.objects[i].window_id = bytestream_get_byte(&buf);
455  ctx->presentation.objects[i].composition_flag = bytestream_get_byte(&buf);
456 
457  ctx->presentation.objects[i].x = bytestream_get_be16(&buf);
458  ctx->presentation.objects[i].y = bytestream_get_be16(&buf);
459 
460  // If cropping
461  if (ctx->presentation.objects[i].composition_flag & 0x80) {
462  ctx->presentation.objects[i].crop_x = bytestream_get_be16(&buf);
463  ctx->presentation.objects[i].crop_y = bytestream_get_be16(&buf);
464  ctx->presentation.objects[i].crop_w = bytestream_get_be16(&buf);
465  ctx->presentation.objects[i].crop_h = bytestream_get_be16(&buf);
466  }
467 
468  ff_dlog(avctx, "Subtitle Placement x=%d, y=%d\n",
469  ctx->presentation.objects[i].x, ctx->presentation.objects[i].y);
470 
471  if (ctx->presentation.objects[i].x > avctx->width ||
472  ctx->presentation.objects[i].y > avctx->height) {
473  av_log(avctx, AV_LOG_ERROR, "Subtitle out of video bounds. x = %d, y = %d, video width = %d, video height = %d.\n",
474  ctx->presentation.objects[i].x,
475  ctx->presentation.objects[i].y,
476  avctx->width, avctx->height);
477  ctx->presentation.objects[i].x = 0;
478  ctx->presentation.objects[i].y = 0;
479  if (avctx->err_recognition & AV_EF_EXPLODE) {
480  return AVERROR_INVALIDDATA;
481  }
482  }
483  }
484 
485  return 0;
486 }
487 
488 /**
489  * Parse the display segment packet.
490  *
491  * The display segment controls the updating of the display.
492  *
493  * @param avctx contains the current codec context
494  * @param data pointer to the data pertaining the subtitle to display
495  * @param buf pointer to the packet to process
496  * @param buf_size size of packet to process
497  */
498 static int display_end_segment(AVCodecContext *avctx, void *data,
499  const uint8_t *buf, int buf_size)
500 {
501  AVSubtitle *sub = data;
502  PGSSubContext *ctx = avctx->priv_data;
503  int64_t pts;
504  PGSSubPalette *palette;
505  int i, ret;
506 
507  pts = ctx->presentation.pts != AV_NOPTS_VALUE ? ctx->presentation.pts : sub->pts;
508  memset(sub, 0, sizeof(*sub));
509  sub->pts = pts;
511  sub->start_display_time = 0;
512  // There is no explicit end time for PGS subtitles. The end time
513  // is defined by the start of the next sub which may contain no
514  // objects (i.e. clears the previous sub)
515  sub->end_display_time = UINT32_MAX;
516  sub->format = 0;
517 
518  // Blank if last object_count was 0.
519  if (!ctx->presentation.object_count)
520  return 1;
521  sub->rects = av_mallocz_array(ctx->presentation.object_count, sizeof(*sub->rects));
522  if (!sub->rects) {
523  return AVERROR(ENOMEM);
524  }
525  palette = find_palette(ctx->presentation.palette_id, &ctx->palettes);
526  if (!palette) {
527  // Missing palette. Should only happen with damaged streams.
528  av_log(avctx, AV_LOG_ERROR, "Invalid palette id %d\n",
529  ctx->presentation.palette_id);
530  avsubtitle_free(sub);
531  return AVERROR_INVALIDDATA;
532  }
533  for (i = 0; i < ctx->presentation.object_count; i++) {
534  PGSSubObject *object;
535 
536  sub->rects[i] = av_mallocz(sizeof(*sub->rects[0]));
537  if (!sub->rects[i]) {
538  avsubtitle_free(sub);
539  return AVERROR(ENOMEM);
540  }
541  sub->num_rects++;
542  sub->rects[i]->type = SUBTITLE_BITMAP;
543 
544  /* Process bitmap */
545  object = find_object(ctx->presentation.objects[i].id, &ctx->objects);
546  if (!object) {
547  // Missing object. Should only happen with damaged streams.
548  av_log(avctx, AV_LOG_ERROR, "Invalid object id %d\n",
549  ctx->presentation.objects[i].id);
550  if (avctx->err_recognition & AV_EF_EXPLODE) {
551  avsubtitle_free(sub);
552  return AVERROR_INVALIDDATA;
553  }
554  // Leaves rect empty with 0 width and height.
555  continue;
556  }
557  if (ctx->presentation.objects[i].composition_flag & 0x40)
559 
560  sub->rects[i]->x = ctx->presentation.objects[i].x;
561  sub->rects[i]->y = ctx->presentation.objects[i].y;
562 
563  if (object->rle) {
564  sub->rects[i]->w = object->w;
565  sub->rects[i]->h = object->h;
566 
567  sub->rects[i]->linesize[0] = object->w;
568 
569  if (object->rle_remaining_len) {
570  av_log(avctx, AV_LOG_ERROR, "RLE data length %u is %u bytes shorter than expected\n",
571  object->rle_data_len, object->rle_remaining_len);
572  if (avctx->err_recognition & AV_EF_EXPLODE) {
573  avsubtitle_free(sub);
574  return AVERROR_INVALIDDATA;
575  }
576  }
577  ret = decode_rle(avctx, sub->rects[i], object->rle, object->rle_data_len);
578  if (ret < 0) {
579  if ((avctx->err_recognition & AV_EF_EXPLODE) ||
580  ret == AVERROR(ENOMEM)) {
581  avsubtitle_free(sub);
582  return ret;
583  }
584  sub->rects[i]->w = 0;
585  sub->rects[i]->h = 0;
586  continue;
587  }
588  }
589  /* Allocate memory for colors */
590  sub->rects[i]->nb_colors = 256;
591  sub->rects[i]->data[1] = av_mallocz(AVPALETTE_SIZE);
592  if (!sub->rects[i]->data[1]) {
593  avsubtitle_free(sub);
594  return AVERROR(ENOMEM);
595  }
596 
597  if (!ctx->forced_subs_only || ctx->presentation.objects[i].composition_flag & 0x40)
598  memcpy(sub->rects[i]->data[1], palette->clut, sub->rects[i]->nb_colors * sizeof(uint32_t));
599 
600 #if FF_API_AVPICTURE
602 {
604  int j;
605  rect = sub->rects[i];
606  for (j = 0; j < 4; j++) {
607  rect->pict.data[j] = rect->data[j];
608  rect->pict.linesize[j] = rect->linesize[j];
609  }
610 }
612 #endif
613  }
614  return 1;
615 }
616 
617 static int decode(AVCodecContext *avctx, void *data, int *data_size,
618  AVPacket *avpkt)
619 {
620  const uint8_t *buf = avpkt->data;
621  int buf_size = avpkt->size;
622 
623  const uint8_t *buf_end;
624  uint8_t segment_type;
625  int segment_length;
626  int i, ret;
627 
628  ff_dlog(avctx, "PGS sub packet:\n");
629 
630  for (i = 0; i < buf_size; i++) {
631  ff_dlog(avctx, "%02x ", buf[i]);
632  if (i % 16 == 15)
633  ff_dlog(avctx, "\n");
634  }
635 
636  if (i & 15)
637  ff_dlog(avctx, "\n");
638 
639  *data_size = 0;
640 
641  /* Ensure that we have received at a least a segment code and segment length */
642  if (buf_size < 3)
643  return -1;
644 
645  buf_end = buf + buf_size;
646 
647  /* Step through buffer to identify segments */
648  while (buf < buf_end) {
649  segment_type = bytestream_get_byte(&buf);
650  segment_length = bytestream_get_be16(&buf);
651 
652  ff_dlog(avctx, "Segment Length %d, Segment Type %x\n", segment_length, segment_type);
653 
654  if (segment_type != DISPLAY_SEGMENT && segment_length > buf_end - buf)
655  break;
656 
657  ret = 0;
658  switch (segment_type) {
659  case PALETTE_SEGMENT:
660  ret = parse_palette_segment(avctx, buf, segment_length);
661  break;
662  case OBJECT_SEGMENT:
663  ret = parse_object_segment(avctx, buf, segment_length);
664  break;
666  ret = parse_presentation_segment(avctx, buf, segment_length, ((AVSubtitle*)(data))->pts);
667  break;
668  case WINDOW_SEGMENT:
669  /*
670  * Window Segment Structure (No new information provided):
671  * 2 bytes: Unknown,
672  * 2 bytes: X position of subtitle,
673  * 2 bytes: Y position of subtitle,
674  * 2 bytes: Width of subtitle,
675  * 2 bytes: Height of subtitle.
676  */
677  break;
678  case DISPLAY_SEGMENT:
679  if (*data_size) {
680  av_log(avctx, AV_LOG_ERROR, "Duplicate display segment\n");
681  ret = AVERROR_INVALIDDATA;
682  break;
683  }
684  ret = display_end_segment(avctx, data, buf, segment_length);
685  if (ret >= 0)
686  *data_size = ret;
687  break;
688  default:
689  av_log(avctx, AV_LOG_ERROR, "Unknown subtitle segment type 0x%x, length %d\n",
690  segment_type, segment_length);
691  ret = AVERROR_INVALIDDATA;
692  break;
693  }
694  if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
695  return ret;
696 
697  buf += segment_length;
698  }
699 
700  return buf_size;
701 }
702 
703 #define OFFSET(x) offsetof(PGSSubContext, x)
704 #define SD AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_DECODING_PARAM
705 static const AVOption options[] = {
706  {"forced_subs_only", "Only show forced subtitles", OFFSET(forced_subs_only), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, SD},
707  { NULL },
708 };
709 
710 static const AVClass pgsdec_class = {
711  .class_name = "PGS subtitle decoder",
712  .item_name = av_default_item_name,
713  .option = options,
714  .version = LIBAVUTIL_VERSION_INT,
715 };
716 
718  .name = "pgssub",
719  .long_name = NULL_IF_CONFIG_SMALL("HDMV Presentation Graphic Stream subtitles"),
720  .type = AVMEDIA_TYPE_SUBTITLE,
722  .priv_data_size = sizeof(PGSSubContext),
723  .init = init_decoder,
724  .close = close_decoder,
725  .decode = decode,
726  .priv_class = &pgsdec_class,
727 };
static int parse_object_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Parse the picture segment packet.
Definition: pgssubdec.c:231
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int x
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:3910
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
#define OFFSET(x)
Definition: pgssubdec.c:703
misc image utilities
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static int parse_presentation_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int64_t pts)
Parse the presentation segment packet.
Definition: pgssubdec.c:388
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:104
const char * g
Definition: vf_curves.c:115
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int nb_colors
number of colors in pict, undefined when pict is not set
Definition: avcodec.h:3914
int size
Definition: avcodec.h:1481
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
#define MAX_NEG_CROP
Definition: mathops.h:31
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1778
unsigned num_rects
Definition: avcodec.h:3948
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:70
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
uint8_t run
Definition: svq3.c:206
AVCodec ff_pgssub_decoder
Definition: pgssubdec.c:717
PGSSubPresentation presentation
Definition: pgssubdec.c:95
AVCodec.
Definition: avcodec.h:3492
attribute_deprecated AVPicture pict
Definition: avcodec.h:3921
#define MAX_OBJECT_REFS
Definition: pgssubdec.c:39
AVSubtitleRect ** rects
Definition: avcodec.h:3949
int w
width of pict, undefined when pict is not set
Definition: avcodec.h:3912
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
uint8_t composition_flag
Definition: pgssubdec.c:52
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:139
uint8_t
#define av_cold
Definition: attributes.h:82
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
AVOptions.
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:92
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
attribute_deprecated int linesize[AV_NUM_DATA_POINTERS]
number of bytes per line
Definition: avcodec.h:3881
PGSSubObjects objects
Definition: pgssubdec.c:97
#define height
uint8_t * data
Definition: avcodec.h:1480
static const AVClass pgsdec_class
Definition: pgssubdec.c:710
#define ff_dlog(a,...)
static int decode(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
Definition: pgssubdec.c:617
int h
height of pict, undefined when pict is not set
Definition: avcodec.h:3913
#define av_log(a,...)
#define cm
Definition: dvbsubdec.c:37
static int parse_palette_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Parse the palette segment packet.
Definition: pgssubdec.c:326
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
Various defines for YUV<->RGB conversion.
#define RGBA(r, g, b, a)
Definition: pgssubdec.c:36
int y
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:3911
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
const char * r
Definition: vf_curves.c:114
static int decode_rle(AVCodecContext *avctx, AVSubtitleRect *rect, const uint8_t *buf, unsigned int buf_size)
Decode the RLE data.
Definition: pgssubdec.c:161
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
static const AVOption options[]
Definition: pgssubdec.c:705
int forced_subs_only
Definition: pgssubdec.c:98
uint32_t end_display_time
Definition: avcodec.h:3947
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:3950
PGSSubObject object[MAX_EPOCH_OBJECTS]
Definition: pgssubdec.c:80
A bitmap, pict will be set.
Definition: avcodec.h:3892
#define AV_SUBTITLE_FLAG_FORCED
Definition: avcodec.h:3907
int linesize[4]
Definition: avcodec.h:3928
#define b
Definition: input.c:41
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2697
static av_cold int close_decoder(AVCodecContext *avctx)
Definition: pgssubdec.c:144
#define width
int width
picture width / height.
Definition: avcodec.h:1741
#define YUV_TO_RGB2_CCIR(r, g, b, y1)
Definition: colorspace.h:55
uint8_t w
Definition: llviddspenc.c:38
static PGSSubObject * find_object(int id, PGSSubObjects *objects)
Definition: pgssubdec.c:115
AVFormatContext * ctx
Definition: movenc.c:48
attribute_deprecated uint8_t * data[AV_NUM_DATA_POINTERS]
pointers to the image data planes
Definition: avcodec.h:3879
uint16_t format
Definition: avcodec.h:3945
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2708
static av_cold int init_decoder(AVCodecContext *avctx)
Definition: pgssubdec.c:137
static int display_end_segment(AVCodecContext *avctx, void *data, const uint8_t *buf, int buf_size)
Parse the display segment packet.
Definition: pgssubdec.c:498
uint8_t * data[4]
data+linesize for the bitmap of this subtitle.
Definition: avcodec.h:3927
#define MAX_EPOCH_OBJECTS
Definition: pgssubdec.c:38
#define YUV_TO_RGB1_CCIR(cb1, cr1)
Definition: colorspace.h:34
Libavcodec external API header.
static struct @320 state
static const int16_t alpha[]
Definition: ilbcdata.h:55
main external API structure.
Definition: avcodec.h:1568
static void flush_cache(AVCodecContext *avctx)
Definition: pgssubdec.c:101
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1081
void * buf
Definition: avisynth_c.h:766
Describe the class of an AVClass context structure.
Definition: log.h:67
Definition: f_ebur128.c:91
PGSSubPalette palette[MAX_EPOCH_PALETTES]
Definition: pgssubdec.c:90
PGSSubObjectRef objects[MAX_OBJECT_REFS]
Definition: pgssubdec.c:65
static int64_t pts
#define flags(name, subs,...)
Definition: cbs_av1.c:561
uint32_t clut[256]
Definition: pgssubdec.c:85
unsigned int rle_remaining_len
Definition: pgssubdec.c:75
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
unsigned int rle_data_len
Definition: pgssubdec.c:74
uint32_t start_display_time
Definition: avcodec.h:3946
#define ff_crop_tab
void * priv_data
Definition: avcodec.h:1595
static PGSSubPalette * find_palette(int id, PGSSubPalettes *palettes)
Definition: pgssubdec.c:126
uint8_t * rle
Definition: pgssubdec.c:73
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
unsigned int rle_buffer_size
Definition: pgssubdec.c:74
#define SD
Definition: pgssubdec.c:704
#define YUV_TO_RGB1_CCIR_BT709(cb1, cr1)
Definition: colorspace.h:44
#define av_freep(p)
SegmentType
Definition: pgssubdec.c:41
#define av_malloc_array(a, b)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:140
enum AVSubtitleType type
Definition: avcodec.h:3930
This structure stores compressed data.
Definition: avcodec.h:1457
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define MAX_EPOCH_PALETTES
Definition: pgssubdec.c:37
PGSSubPalettes palettes
Definition: pgssubdec.c:96
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191