libavfilter/vf_readeia608.c - third_party/ffmpeg - Git at Google

 /*
  * Copyright (c) 2017 Paul B Mahol
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * FFmpeg is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */

 /**
  * @file
  * Filter for reading closed captioning data (EIA-608).
  * See also https://en.wikipedia.org/wiki/EIA-608
  */

 #include <string.h>

 #include "libavutil/internal.h"
 #include "libavutil/opt.h"
 #include "libavutil/pixdesc.h"
 #include "libavutil/timestamp.h"

 #include "avfilter.h"
 #include "formats.h"
 #include "internal.h"
 #include "video.h"

 #define FALL 0
 #define RISE 1

 typedef struct ReadEIA608Context {
     const AVClass *class;
     int start, end;
     int min_range;
     int max_peak_diff;
     int max_period_diff;
     int max_start_diff;
     int nb_found;
     int white;
     int black;
     float mpd, mhd, msd, mac, spw, bhd, wth, bth;
     int chp;
 } ReadEIA608Context;

 #define OFFSET(x) offsetof(ReadEIA608Context, x)
 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

 static const AVOption readeia608_options[] = {
     { "scan_min", "set from which line to scan for codes",                            OFFSET(start), AV_OPT_TYPE_INT,   {.i64=0},       0, INT_MAX, FLAGS },
     { "scan_max", "set to which line to scan for codes",                              OFFSET(end),   AV_OPT_TYPE_INT,   {.i64=29},      0, INT_MAX, FLAGS },
     { "mac",      "set minimal acceptable amplitude change for sync codes detection", OFFSET(mac),   AV_OPT_TYPE_FLOAT, {.dbl=.2},  0.001,       1, FLAGS },
     { "spw",      "set ratio of width reserved for sync code detection",              OFFSET(spw),   AV_OPT_TYPE_FLOAT, {.dbl=.27},   0.1,     0.7, FLAGS },
     { "mhd",      "set max peaks height difference for sync code detection",          OFFSET(mhd),   AV_OPT_TYPE_FLOAT, {.dbl=.1},      0,     0.5, FLAGS },
     { "mpd",      "set max peaks period difference for sync code detection",          OFFSET(mpd),   AV_OPT_TYPE_FLOAT, {.dbl=.1},      0,     0.5, FLAGS },
     { "msd",      "set first two max start code bits differences",                    OFFSET(msd),   AV_OPT_TYPE_FLOAT, {.dbl=.02},     0,     0.5, FLAGS },
     { "bhd",      "set min ratio of bits height compared to 3rd start code bit",      OFFSET(bhd),   AV_OPT_TYPE_FLOAT, {.dbl=.75},  0.01,       1, FLAGS },
     { "th_w",     "set white color threshold",                                        OFFSET(wth),   AV_OPT_TYPE_FLOAT, {.dbl=.35},   0.1,       1, FLAGS },
     { "th_b",     "set black color threshold",                                        OFFSET(bth),   AV_OPT_TYPE_FLOAT, {.dbl=.15},     0,     0.5, FLAGS },
     { "chp",      "check and apply parity bit",                                       OFFSET(chp),   AV_OPT_TYPE_BOOL,  {.i64= 0},      0,       1, FLAGS },
     { NULL }
 };

 AVFILTER_DEFINE_CLASS(readeia608);

 static int query_formats(AVFilterContext *ctx)
 {
     static const enum AVPixelFormat pixel_fmts[] = {
         AV_PIX_FMT_GRAY8,
         AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
         AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
         AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
         AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
         AV_PIX_FMT_YUVJ411P,
         AV_PIX_FMT_NONE
     };
     AVFilterFormats *formats = ff_make_format_list(pixel_fmts);
     if (!formats)
         return AVERROR(ENOMEM);
     return ff_set_common_formats(ctx, formats);
 }

 static int config_input(AVFilterLink *inlink)
 {
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
     AVFilterContext *ctx = inlink->dst;
     ReadEIA608Context *s = ctx->priv;
     int depth = desc->comp[0].depth;

     if (s->end >= inlink->h) {
         av_log(ctx, AV_LOG_WARNING, "Last line to scan too large, clipping.\n");
         s->end = inlink->h - 1;
     }

     if (s->start > s->end) {
         av_log(ctx, AV_LOG_ERROR, "Invalid range.\n");
         return AVERROR(EINVAL);
     }

     s->min_range = s->mac * ((1 << depth) - 1);
     s->max_peak_diff = s->mhd * ((1 << depth) - 1);
     s->max_period_diff = s->mpd * ((1 << depth) - 1);
     s->max_start_diff = s->msd * ((1 << depth) - 1);
     s->white = s->wth * ((1 << depth) - 1);
     s->black = s->bth * ((1 << depth) - 1);

     return 0;
 }

 static void extract_line(AVFilterContext *ctx, AVFilterLink *inlink, AVFrame *in, int line)
 {
     ReadEIA608Context *s = ctx->priv;
     int max = 0, min = INT_MAX;
     int i, ch, range = 0;
     const uint8_t *src;
     uint16_t clock[8][2] = { { 0 } };
     const int sync_width = s->spw * in->width;
     int last = 0, peaks = 0, max_peak_diff = 0, dir = RISE;
     const int width_per_bit = (in->width - sync_width) / 19;
     uint8_t byte[2] = { 0 };
     int s1, s2, s3, parity;

     src = &in->data[0][line * in->linesize[0]];
     for (i = 0; i < sync_width; i++) {
         max = FFMAX(max, src[i]);
         min = FFMIN(min, src[i]);
     }

     range = max - min;
     if (range < s->min_range)
         return;

     for (i = 0; i < sync_width; i++) {
         int Y = src[i];

         if (dir == RISE) {
             if (Y < last) {
                 dir = FALL;
                 if (last >= s->white) {
                     clock[peaks][0] = last;
                     clock[peaks][1] = i;
                     peaks++;
                     if (peaks > 7)
                         break;
                 }
             }
         } else if (dir == FALL) {
             if (Y > last && last <= s->black) {
                 dir = RISE;
             }
         }
         last = Y;
     }

     if (peaks != 7)
         return;

     for (i = 1; i < 7; i++)
         max_peak_diff = FFMAX(max_peak_diff, FFABS(clock[i][0] - clock[i-1][0]));

     if (max_peak_diff > s->max_peak_diff)
         return;

     max = 0; min = INT_MAX;
     for (i = 1; i < 7; i++) {
         max = FFMAX(max, FFABS(clock[i][1] - clock[i-1][1]));
         min = FFMIN(min, FFABS(clock[i][1] - clock[i-1][1]));
     }

     range = max - min;
     if (range > s->max_period_diff)
         return;

     s1 = src[sync_width + width_per_bit * 0 + width_per_bit / 2];
     s2 = src[sync_width + width_per_bit * 1 + width_per_bit / 2];
     s3 = src[sync_width + width_per_bit * 2 + width_per_bit / 2];

     if (FFABS(s1 - s2) > s->max_start_diff || s1 > s->black || s2 > s->black || s3 < s->white)
         return;

     for (ch = 0; ch < 2; ch++) {
         for (parity = 0, i = 0; i < 8; i++) {
             int b = src[sync_width + width_per_bit * (i + 3 + 8 * ch) + width_per_bit / 2];

             if (b - s1 > (s3 - s1) * s->bhd) {
                 b = 1;
                 parity++;
             } else {
                 b = 0;
             }
             byte[ch] |= b << i;
         }

         if (s->chp) {
             if (!(parity & 1)) {
                 byte[ch] = 0;
             }
         }
     }

     {
         uint8_t key[128], value[128];

         snprintf(key, sizeof(key), "lavfi.readeia608.%d.cc", s->nb_found);
         snprintf(value, sizeof(value), "0x%02X%02X", byte[0], byte[1]);
         av_dict_set(&in->metadata, key, value, 0);

         snprintf(key, sizeof(key), "lavfi.readeia608.%d.line", s->nb_found);
         snprintf(value, sizeof(value), "%d", line);
         av_dict_set(&in->metadata, key, value, 0);
     }

     s->nb_found++;
 }

 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 {
     AVFilterContext *ctx  = inlink->dst;
     AVFilterLink *outlink = ctx->outputs[0];
     ReadEIA608Context *s = ctx->priv;
     int i;

     s->nb_found = 0;
     for (i = s->start; i <= s->end; i++)
         extract_line(ctx, inlink, in, i);

     return ff_filter_frame(outlink, in);
 }

 static const AVFilterPad readeia608_inputs[] = {
     {
         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
         .config_props = config_input,
     },
     { NULL }
 };

 static const AVFilterPad readeia608_outputs[] = {
     {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
     { NULL }
 };

 AVFilter ff_vf_readeia608 = {
     .name          = "readeia608",
     .description   = NULL_IF_CONFIG_SMALL("Read EIA-608 Closed Caption codes from input video and write them to frame metadata."),
     .priv_size     = sizeof(ReadEIA608Context),
     .priv_class    = &readeia608_class,
     .query_formats = query_formats,
     .inputs        = readeia608_inputs,
     .outputs       = readeia608_outputs,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
	/*
	* Copyright (c) 2017 Paul B Mahol
	*
	* This file is part of FFmpeg.
	*
	* FFmpeg is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* FFmpeg is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with FFmpeg; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	/**
	* @file
	* Filter for reading closed captioning data (EIA-608).
	* See also https://en.wikipedia.org/wiki/EIA-608
	*/

	#include <string.h>

	#include "libavutil/internal.h"
	#include "libavutil/opt.h"
	#include "libavutil/pixdesc.h"
	#include "libavutil/timestamp.h"

	#include "avfilter.h"
	#include "formats.h"
	#include "internal.h"
	#include "video.h"

	#define FALL 0
	#define RISE 1

	typedef struct ReadEIA608Context {
	const AVClass *class;
	int start, end;
	int min_range;
	int max_peak_diff;
	int max_period_diff;
	int max_start_diff;
	int nb_found;
	int white;
	int black;
	float mpd, mhd, msd, mac, spw, bhd, wth, bth;
	int chp;
	} ReadEIA608Context;

	#define OFFSET(x) offsetof(ReadEIA608Context, x)
	#define FLAGS AV_OPT_FLAG_VIDEO_PARAM\|AV_OPT_FLAG_FILTERING_PARAM

	static const AVOption readeia608_options[] = {
	{ "scan_min", "set from which line to scan for codes", OFFSET(start), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, FLAGS },
	{ "scan_max", "set to which line to scan for codes", OFFSET(end), AV_OPT_TYPE_INT, {.i64=29}, 0, INT_MAX, FLAGS },
	{ "mac", "set minimal acceptable amplitude change for sync codes detection", OFFSET(mac), AV_OPT_TYPE_FLOAT, {.dbl=.2}, 0.001, 1, FLAGS },
	{ "spw", "set ratio of width reserved for sync code detection", OFFSET(spw), AV_OPT_TYPE_FLOAT, {.dbl=.27}, 0.1, 0.7, FLAGS },
	{ "mhd", "set max peaks height difference for sync code detection", OFFSET(mhd), AV_OPT_TYPE_FLOAT, {.dbl=.1}, 0, 0.5, FLAGS },
	{ "mpd", "set max peaks period difference for sync code detection", OFFSET(mpd), AV_OPT_TYPE_FLOAT, {.dbl=.1}, 0, 0.5, FLAGS },
	{ "msd", "set first two max start code bits differences", OFFSET(msd), AV_OPT_TYPE_FLOAT, {.dbl=.02}, 0, 0.5, FLAGS },
	{ "bhd", "set min ratio of bits height compared to 3rd start code bit", OFFSET(bhd), AV_OPT_TYPE_FLOAT, {.dbl=.75}, 0.01, 1, FLAGS },
	{ "th_w", "set white color threshold", OFFSET(wth), AV_OPT_TYPE_FLOAT, {.dbl=.35}, 0.1, 1, FLAGS },
	{ "th_b", "set black color threshold", OFFSET(bth), AV_OPT_TYPE_FLOAT, {.dbl=.15}, 0, 0.5, FLAGS },
	{ "chp", "check and apply parity bit", OFFSET(chp), AV_OPT_TYPE_BOOL, {.i64= 0}, 0, 1, FLAGS },
	{ NULL }
	};

	AVFILTER_DEFINE_CLASS(readeia608);

	static int query_formats(AVFilterContext *ctx)
	{
	static const enum AVPixelFormat pixel_fmts[] = {
	AV_PIX_FMT_GRAY8,
	AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
	AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
	AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
	AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
	AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
	AV_PIX_FMT_YUVJ411P,
	AV_PIX_FMT_NONE
	};
	AVFilterFormats *formats = ff_make_format_list(pixel_fmts);
	if (!formats)
	return AVERROR(ENOMEM);
	return ff_set_common_formats(ctx, formats);
	}

	static int config_input(AVFilterLink *inlink)
	{
	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
	AVFilterContext *ctx = inlink->dst;
	ReadEIA608Context *s = ctx->priv;
	int depth = desc->comp[0].depth;

	if (s->end >= inlink->h) {
	av_log(ctx, AV_LOG_WARNING, "Last line to scan too large, clipping.\n");
	s->end = inlink->h - 1;
	}

	if (s->start > s->end) {
	av_log(ctx, AV_LOG_ERROR, "Invalid range.\n");
	return AVERROR(EINVAL);
	}

	s->min_range = s->mac * ((1 << depth) - 1);
	s->max_peak_diff = s->mhd * ((1 << depth) - 1);
	s->max_period_diff = s->mpd * ((1 << depth) - 1);
	s->max_start_diff = s->msd * ((1 << depth) - 1);
	s->white = s->wth * ((1 << depth) - 1);
	s->black = s->bth * ((1 << depth) - 1);

	return 0;
	}

	static void extract_line(AVFilterContext ctx, AVFilterLink inlink, AVFrame *in, int line)
	{
	ReadEIA608Context *s = ctx->priv;
	int max = 0, min = INT_MAX;
	int i, ch, range = 0;
	const uint8_t *src;
	uint16_t clock[8][2] = { { 0 } };
	const int sync_width = s->spw * in->width;
	int last = 0, peaks = 0, max_peak_diff = 0, dir = RISE;
	const int width_per_bit = (in->width - sync_width) / 19;
	uint8_t byte[2] = { 0 };
	int s1, s2, s3, parity;

	src = &in->data[0][line * in->linesize[0]];
	for (i = 0; i < sync_width; i++) {
	max = FFMAX(max, src[i]);
	min = FFMIN(min, src[i]);
	}

	range = max - min;
	if (range < s->min_range)
	return;

	for (i = 0; i < sync_width; i++) {
	int Y = src[i];

	if (dir == RISE) {
	if (Y < last) {
	dir = FALL;
	if (last >= s->white) {
	clock[peaks][0] = last;
	clock[peaks][1] = i;
	peaks++;
	if (peaks > 7)
	break;
	}
	}
	} else if (dir == FALL) {
	if (Y > last && last <= s->black) {
	dir = RISE;
	}
	}
	last = Y;
	}

	if (peaks != 7)
	return;

	for (i = 1; i < 7; i++)
	max_peak_diff = FFMAX(max_peak_diff, FFABS(clock[i][0] - clock[i-1][0]));

	if (max_peak_diff > s->max_peak_diff)
	return;

	max = 0; min = INT_MAX;
	for (i = 1; i < 7; i++) {
	max = FFMAX(max, FFABS(clock[i][1] - clock[i-1][1]));
	min = FFMIN(min, FFABS(clock[i][1] - clock[i-1][1]));
	}

	range = max - min;
	if (range > s->max_period_diff)
	return;

	s1 = src[sync_width + width_per_bit * 0 + width_per_bit / 2];
	s2 = src[sync_width + width_per_bit * 1 + width_per_bit / 2];
	s3 = src[sync_width + width_per_bit * 2 + width_per_bit / 2];

	if (FFABS(s1 - s2) > s->max_start_diff \|\| s1 > s->black \|\| s2 > s->black \|\| s3 < s->white)
	return;

	for (ch = 0; ch < 2; ch++) {
	for (parity = 0, i = 0; i < 8; i++) {
	int b = src[sync_width + width_per_bit * (i + 3 + 8 * ch) + width_per_bit / 2];

	if (b - s1 > (s3 - s1) * s->bhd) {
	b = 1;
	parity++;
	} else {
	b = 0;
	}
	byte[ch] \|= b << i;
	}

	if (s->chp) {
	if (!(parity & 1)) {
	byte[ch] = 0;
	}
	}
	}

	{
	uint8_t key[128], value[128];

	snprintf(key, sizeof(key), "lavfi.readeia608.%d.cc", s->nb_found);
	snprintf(value, sizeof(value), "0x%02X%02X", byte[0], byte[1]);
	av_dict_set(&in->metadata, key, value, 0);

	snprintf(key, sizeof(key), "lavfi.readeia608.%d.line", s->nb_found);
	snprintf(value, sizeof(value), "%d", line);
	av_dict_set(&in->metadata, key, value, 0);
	}

	s->nb_found++;
	}

	static int filter_frame(AVFilterLink inlink, AVFrame in)
	{
	AVFilterContext *ctx = inlink->dst;
	AVFilterLink *outlink = ctx->outputs[0];
	ReadEIA608Context *s = ctx->priv;
	int i;

	s->nb_found = 0;
	for (i = s->start; i <= s->end; i++)
	extract_line(ctx, inlink, in, i);

	return ff_filter_frame(outlink, in);
	}

	static const AVFilterPad readeia608_inputs[] = {
	{
	.name = "default",
	.type = AVMEDIA_TYPE_VIDEO,
	.filter_frame = filter_frame,
	.config_props = config_input,
	},
	{ NULL }
	};

	static const AVFilterPad readeia608_outputs[] = {
	{
	.name = "default",
	.type = AVMEDIA_TYPE_VIDEO,
	},
	{ NULL }
	};

	AVFilter ff_vf_readeia608 = {
	.name = "readeia608",
	.description = NULL_IF_CONFIG_SMALL("Read EIA-608 Closed Caption codes from input video and write them to frame metadata."),
	.priv_size = sizeof(ReadEIA608Context),
	.priv_class = &readeia608_class,
	.query_formats = query_formats,
	.inputs = readeia608_inputs,
	.outputs = readeia608_outputs,
	.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
	};