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;
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) {
363  } else {
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);
433  if (ctx->presentation.object_count > MAX_OBJECT_REFS) {
434  av_log(avctx, AV_LOG_ERROR,
435  "Invalid number of presentation objects %d\n",
436  ctx->presentation.object_count);
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;
510  ctx->presentation.pts = AV_NOPTS_VALUE;
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 *got_sub_ptr,
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  *got_sub_ptr = 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 (*got_sub_ptr) {
680  av_log(avctx, AV_LOG_ERROR, "Duplicate display segment\n");
682  break;
683  }
684  ret = display_end_segment(avctx, data, buf, segment_length);
685  if (ret >= 0)
686  *got_sub_ptr = 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);
692  break;
693  }
694  if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
696  *got_sub_ptr = 0;
697  return ret;
698  }
699 
700  buf += segment_length;
701  }
702 
703  return buf_size;
704 }
705 
706 #define OFFSET(x) offsetof(PGSSubContext, x)
707 #define SD AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_DECODING_PARAM
708 static const AVOption options[] = {
709  {"forced_subs_only", "Only show forced subtitles", OFFSET(forced_subs_only), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, SD},
710  { NULL },
711 };
712 
713 static const AVClass pgsdec_class = {
714  .class_name = "PGS subtitle decoder",
715  .item_name = av_default_item_name,
716  .option = options,
717  .version = LIBAVUTIL_VERSION_INT,
718 };
719 
721  .name = "pgssub",
722  .long_name = NULL_IF_CONFIG_SMALL("HDMV Presentation Graphic Stream subtitles"),
723  .type = AVMEDIA_TYPE_SUBTITLE,
725  .priv_data_size = sizeof(PGSSubContext),
726  .init = init_decoder,
727  .close = close_decoder,
728  .decode = decode,
729  .priv_class = &pgsdec_class,
730 };
AVSubtitle
Definition: avcodec.h:2694
rect::w
int w
Definition: f_ebur128.c:91
AVCodec
AVCodec.
Definition: codec.h:190
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
PGSSubObjectRef
Definition: pgssubdec.c:49
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
r
const char * r
Definition: vf_curves.c:114
AVERROR
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
AVSubtitle::rects
AVSubtitleRect ** rects
Definition: avcodec.h:2699
opt.h
color
Definition: vf_paletteuse.c:582
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
init_decoder
static av_cold int init_decoder(AVCodecContext *avctx)
Definition: pgssubdec.c:137
rect
Definition: f_ebur128.c:91
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1655
PGSSubObjects
Definition: pgssubdec.c:78
AVSubtitleRect
Definition: avcodec.h:2659
AVSubtitle::num_rects
unsigned num_rects
Definition: avcodec.h:2698
PGSSubObject
Definition: pgssubdec.c:69
PGSSubObjectRef::y
int y
Definition: pgssubdec.c:54
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:355
AVOption
AVOption.
Definition: opt.h:246
b
#define b
Definition: input.c:41
PGSSubContext::objects
PGSSubObjects objects
Definition: pgssubdec.c:97
data
const char data[16]
Definition: mxf.c:91
options
static const AVOption options[]
Definition: pgssubdec.c:708
PALETTE_SEGMENT
@ PALETTE_SEGMENT
Definition: pgssubdec.c:42
AVSubtitleRect::linesize
int linesize[4]
Definition: avcodec.h:2678
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
YUV_TO_RGB1_CCIR
#define YUV_TO_RGB1_CCIR(cb1, cr1)
Definition: colorspace.h:34
AV_CODEC_ID_HDMV_PGS_SUBTITLE
@ AV_CODEC_ID_HDMV_PGS_SUBTITLE
Definition: codec_id.h:514
parse_presentation_segment
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
ff_crop_tab
#define ff_crop_tab
Definition: motionpixels_tablegen.c:26
PGSSubObjectRef::crop_h
int crop_h
Definition: pgssubdec.c:58
find_object
static PGSSubObject * find_object(int id, PGSSubObjects *objects)
Definition: pgssubdec.c:115
AVSubtitleRect::x
int x
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:2660
PGSSubPalette
Definition: pgssubdec.c:83
display_end_segment
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
pts
static int64_t pts
Definition: transcode_aac.c:647
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1124
colorspace.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:90
parse_object_segment
static int parse_object_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Parse the picture segment packet.
Definition: pgssubdec.c:231
PGSSubPalettes::palette
PGSSubPalette palette[MAX_EPOCH_PALETTES]
Definition: pgssubdec.c:90
YUV_TO_RGB1_CCIR_BT709
#define YUV_TO_RGB1_CCIR_BT709(cb1, cr1)
Definition: colorspace.h:44
width
#define width
PGSSubPalettes
Definition: pgssubdec.c:88
g
const char * g
Definition: vf_curves.c:115
AVSubtitleRect::y
int y
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:2661
OFFSET
#define OFFSET(x)
Definition: pgssubdec.c:706
ctx
AVFormatContext * ctx
Definition: movenc.c:48
PGSSubPresentation::id_number
int id_number
Definition: pgssubdec.c:62
AVSubtitle::pts
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2700
PGSSubObjects::object
PGSSubObject object[MAX_EPOCH_OBJECTS]
Definition: pgssubdec.c:80
PGSSubObjects::count
int count
Definition: pgssubdec.c:79
AVSubtitleRect::w
int w
width of pict, undefined when pict is not set
Definition: avcodec.h:2662
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
decode
static int decode(AVCodecContext *avctx, void *data, int *got_sub_ptr, AVPacket *avpkt)
Definition: pgssubdec.c:617
NULL
#define NULL
Definition: coverity.c:32
run
uint8_t run
Definition: svq3.c:209
ff_pgssub_decoder
AVCodec ff_pgssub_decoder
Definition: pgssubdec.c:720
PGSSubObjectRef::composition_flag
uint8_t composition_flag
Definition: pgssubdec.c:52
PRESENTATION_SEGMENT
@ PRESENTATION_SEGMENT
Definition: pgssubdec.c:44
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AVSubtitleRect::data
uint8_t * data[4]
data+linesize for the bitmap of this subtitle.
Definition: avcodec.h:2677
mathops.h
MAX_OBJECT_REFS
#define MAX_OBJECT_REFS
Definition: pgssubdec.c:39
DISPLAY_SEGMENT
@ DISPLAY_SEGMENT
Definition: pgssubdec.c:46
YUV_TO_RGB2_CCIR
#define YUV_TO_RGB2_CCIR(r, g, b, y1)
Definition: colorspace.h:55
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1666
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
PGSSubObject::rle
uint8_t * rle
Definition: pgssubdec.c:73
find_palette
static PGSSubPalette * find_palette(int id, PGSSubPalettes *palettes)
Definition: pgssubdec.c:126
PGSSubContext::presentation
PGSSubPresentation presentation
Definition: pgssubdec.c:95
AVPacket::size
int size
Definition: packet.h:356
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:332
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:92
state
static struct @314 state
PGSSubPresentation::palette_id
int palette_id
Definition: pgssubdec.c:63
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
rect::h
int h
Definition: f_ebur128.c:91
PGSSubObjectRef::crop_w
int crop_w
Definition: pgssubdec.c:57
AVSubtitle::end_display_time
uint32_t end_display_time
Definition: avcodec.h:2697
SegmentType
SegmentType
Definition: pgssubdec.c:41
AVSubtitleRect::type
enum AVSubtitleType type
Definition: avcodec.h:2680
height
#define height
PGSSubPalette::clut
uint32_t clut[256]
Definition: pgssubdec.c:85
AV_SUBTITLE_FLAG_FORCED
#define AV_SUBTITLE_FLAG_FORCED
Definition: avcodec.h:2657
SUBTITLE_BITMAP
@ SUBTITLE_BITMAP
A bitmap, pict will be set.
Definition: avcodec.h:2642
PGSSubPresentation
Definition: pgssubdec.c:61
PGSSubPresentation::object_count
int object_count
Definition: pgssubdec.c:64
AVSubtitleRect::flags
int flags
Definition: avcodec.h:2691
PGSSubContext::forced_subs_only
int forced_subs_only
Definition: pgssubdec.c:98
MAX_EPOCH_PALETTES
#define MAX_EPOCH_PALETTES
Definition: pgssubdec.c:37
PGSSubObject::rle_remaining_len
unsigned int rle_remaining_len
Definition: pgssubdec.c:75
AVSubtitle::format
uint16_t format
Definition: avcodec.h:2695
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
PGSSubObject::rle_data_len
unsigned int rle_data_len
Definition: pgssubdec.c:74
PGSSubPresentation::objects
PGSSubObjectRef objects[MAX_OBJECT_REFS]
Definition: pgssubdec.c:65
AVSubtitleRect::nb_colors
int nb_colors
number of colors in pict, undefined when pict is not set
Definition: avcodec.h:2664
PGSSubPalette::id
int id
Definition: pgssubdec.c:84
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
WINDOW_SEGMENT
@ WINDOW_SEGMENT
Definition: pgssubdec.c:45
PGSSubPresentation::pts
int64_t pts
Definition: pgssubdec.c:66
av_fast_padded_malloc
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
decode_rle
static int decode_rle(AVCodecContext *avctx, AVSubtitleRect *rect, const uint8_t *buf, unsigned int buf_size)
Decode the RLE data.
Definition: pgssubdec.c:161
uint8_t
uint8_t
Definition: audio_convert.c:194
MAX_EPOCH_OBJECTS
#define MAX_EPOCH_OBJECTS
Definition: pgssubdec.c:38
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
PGSSubObjectRef::id
int id
Definition: pgssubdec.c:50
AVCodecContext::height
int height
Definition: avcodec.h:699
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
avcodec.h
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
ret
ret
Definition: filter_design.txt:187
AVSubtitleRect::h
int h
height of pict, undefined when pict is not set
Definition: avcodec.h:2663
SD
#define SD
Definition: pgssubdec.c:707
AVClass::class_name
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
AVCodecContext
main external API structure.
Definition: avcodec.h:526
PGSSubObject::h
int h
Definition: pgssubdec.c:72
PGSSubObject::w
int w
Definition: pgssubdec.c:71
PGSSubContext
Definition: pgssubdec.c:93
PGSSubObjectRef::window_id
int window_id
Definition: pgssubdec.c:51
PGSSubObjectRef::x
int x
Definition: pgssubdec.c:53
close_decoder
static av_cold int close_decoder(AVCodecContext *avctx)
Definition: pgssubdec.c:144
cm
#define cm
Definition: dvbsubdec.c:37
parse_palette_segment
static int parse_palette_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Parse the palette segment packet.
Definition: pgssubdec.c:326
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
ff_set_dimensions
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
RGBA
#define RGBA(r, g, b, a)
Definition: pgssubdec.c:36
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:240
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:216
OBJECT_SEGMENT
@ OBJECT_SEGMENT
Definition: pgssubdec.c:43
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:699
bytestream.h
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
PGSSubObject::id
int id
Definition: pgssubdec.c:70
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
PGSSubObjectRef::crop_y
int crop_y
Definition: pgssubdec.c:56
PGSSubContext::palettes
PGSSubPalettes palettes
Definition: pgssubdec.c:96
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
h
h
Definition: vp9dsp_template.c:2038
MAX_NEG_CROP
#define MAX_NEG_CROP
Definition: mathops.h:31
flush_cache
static void flush_cache(AVCodecContext *avctx)
Definition: pgssubdec.c:101
PGSSubPalettes::count
int count
Definition: pgssubdec.c:89
AVSubtitle::start_display_time
uint32_t start_display_time
Definition: avcodec.h:2696
pgsdec_class
static const AVClass pgsdec_class
Definition: pgssubdec.c:713
PGSSubObject::rle_buffer_size
unsigned int rle_buffer_size
Definition: pgssubdec.c:74
PGSSubObjectRef::crop_x
int crop_x
Definition: pgssubdec.c:55