May 2018 - ffmpeg-devel - lists.ffmpeg.org

[PATCH] avformat/avlanguage: deprecate av_convert_lang_to and make it internal
by James Almer 27 Nov '19

27 Nov '19

The header was never installed and the function is only used in libavformat Signed-off-by: James Almer <jamrial(a)gmail.com> --- libavformat/asfdec_f.c | 2 +- libavformat/asfdec_o.c | 2 +- libavformat/asfenc.c | 2 +- libavformat/avienc.c | 2 +- libavformat/avlanguage.c | 11 +++++++++-- libavformat/avlanguage.h | 7 +++++++ libavformat/matroskaenc.c | 2 +- 7 files changed, 21 insertions(+), 7 deletions(-) diff --git a/libavformat/asfdec_f.c b/libavformat/asfdec_f.c index 2c81b13..b973eff 100644 --- a/libavformat/asfdec_f.c +++ b/libavformat/asfdec_f.c @@ -912,7 +912,7 @@ static int asf_read_header(AVFormatContext *s) const char *rfc1766 = asf->stream_languages[asf->streams[i].stream_language_index]; if (rfc1766 && strlen(rfc1766) > 1) { const char primary_tag[3] = { rfc1766[0], rfc1766[1], '\0' }; // ignore country code if any - const char *iso6392 = av_convert_lang_to(primary_tag, + const char *iso6392 = ff_convert_lang_to(primary_tag, AV_LANG_ISO639_2_BIBL); if (iso6392) av_dict_set(&st->metadata, "language", iso6392, 0); diff --git a/libavformat/asfdec_o.c b/libavformat/asfdec_o.c index 1c564a8..f8caf16 100644 --- a/libavformat/asfdec_o.c +++ b/libavformat/asfdec_o.c @@ -829,7 +829,7 @@ static void set_language(AVFormatContext *s, const char *rfc1766, AVDictionary * // language abbr should contain at least 2 chars if (rfc1766 && strlen(rfc1766) > 1) { const char primary_tag[3] = { rfc1766[0], rfc1766[1], '\0' }; // ignore country code if any - const char *iso6392 = av_convert_lang_to(primary_tag, + const char *iso6392 = ff_convert_lang_to(primary_tag, AV_LANG_ISO639_2_BIBL); if (iso6392) if (av_dict_set(met, "language", iso6392, 0) < 0) diff --git a/libavformat/asfenc.c b/libavformat/asfenc.c index cfa4fad..93ab167 100644 --- a/libavformat/asfenc.c +++ b/libavformat/asfenc.c @@ -431,7 +431,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, entry = av_dict_get(s->streams[n]->metadata, "language", NULL, 0); if (entry) { - const char *iso6391lang = av_convert_lang_to(entry->value, AV_LANG_ISO639_1); + const char *iso6391lang = ff_convert_lang_to(entry->value, AV_LANG_ISO639_1); if (iso6391lang) { int i; for (i = 0; i < asf->nb_languages; i++) { diff --git a/libavformat/avienc.c b/libavformat/avienc.c index c908c21..59ad2b2 100644 --- a/libavformat/avienc.c +++ b/libavformat/avienc.c @@ -435,7 +435,7 @@ static int avi_write_header(AVFormatContext *s) } if (par->codec_id == AV_CODEC_ID_XSUB && (t = av_dict_get(s->streams[i]->metadata, "language", NULL, 0))) { - const char* langstr = av_convert_lang_to(t->value, AV_LANG_ISO639_1); + const char* langstr = ff_convert_lang_to(t->value, AV_LANG_ISO639_1); t = NULL; if (langstr) { char* str = av_asprintf("Subtitle - %s-xx;02", langstr); diff --git a/libavformat/avlanguage.c b/libavformat/avlanguage.c index 39f2560..f5d2ddf 100644 --- a/libavformat/avlanguage.c +++ b/libavformat/avlanguage.c @@ -733,7 +733,7 @@ static int lang_table_compare(const void *lhs, const void *rhs) return strcmp(lhs, ((const LangEntry *)rhs)->str); } -const char *av_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace) +const char *ff_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace) { int i; const LangEntry *entry = NULL; @@ -759,7 +759,14 @@ const char *av_convert_lang_to(const char *lang, enum AVLangCodespace target_cod entry = lang_table + entry->next_equivalent; if (target_codespace == AV_LANG_ISO639_2_TERM) - return av_convert_lang_to(lang, AV_LANG_ISO639_2_BIBL); + return ff_convert_lang_to(lang, AV_LANG_ISO639_2_BIBL); return NULL; } + +#if LIBAVFORMAT_VERSION_MAJOR < 58 +const char *av_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace) +{ + return ff_convert_lang_to(lang, target_codespace); +} +#endif diff --git a/libavformat/avlanguage.h b/libavformat/avlanguage.h index 7fb8968..8b91b2a 100644 --- a/libavformat/avlanguage.h +++ b/libavformat/avlanguage.h @@ -21,6 +21,9 @@ #ifndef AVFORMAT_AVLANGUAGE_H #define AVFORMAT_AVLANGUAGE_H +#include "libavutil/attributes.h" +#include "libavformat/version.h" + /** * Known language codespaces */ @@ -34,6 +37,10 @@ enum AVLangCodespace { * Convert a language code to a target codespace. The source codespace is guessed. * @return NULL if the provided lang is null or invalid. */ +const char *ff_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace); +#if LIBAVFORMAT_VERSION_MAJOR < 58 +attribute_deprecated const char *av_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace); +#endif #endif /* AVFORMAT_AVLANGUAGE_H */ diff --git a/libavformat/matroskaenc.c b/libavformat/matroskaenc.c index 4cd9878..2bf9b30 100644 --- a/libavformat/matroskaenc.c +++ b/libavformat/matroskaenc.c @@ -1257,7 +1257,7 @@ static int mkv_write_simpletag(AVIOContext *pb, AVDictionaryEntry *t) return AVERROR(ENOMEM); if ((p = strrchr(p, '-')) && - (lang = av_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL))) + (lang = ff_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL))) *p = 0; p = key; -- 2.8.1

3 5

[PATCH] lavf/mov: initial support for reading HEIF images
by Rodger Combs 12 Nov '19

12 Nov '19

There's a decent chance this doesn't work on [pretty much anything other than the samples I tested it with], but I haven't found very many samples, and don't want to implement the rest of the features blind with nothing but a spec, and most of it's pretty over-the-top anyway. For some reason my phone running iOS 11 doesn't actually export HEIFs; it just gives me JPEGs with a .HEIC extension. HEIF is basically just an overengineered new mechanism for attaching still pictures to MP4 files. Its atoms can exist along with a moov, or without one. This can probably seek-thrash pretty badly in some cases, so if it becomes common to use this to attach pictures to audio or video files, it'd probably be worth adding an "ignore_attached_pics" option, a la "ignore_chapters". It'd be possible to optimize some of the seeks out by adding some more internal state (this is a naive implementation of a very implementer-unfriendly format), but some are inherent to the design, like with "chap" chapters. Short rant: this whole format is crazy. There are a bunch of variable-size fields ("in case you ever need more than 2^16 pictures in a file!", and also "in case you want to save space by using 3 bytes for the size instead of 4!"), and everything has extra cruft at every opportunity in the name of future extensibility. If somebody wants to explain why an 8-byte atom containing a width and a height needs another 4 bytes for version and flags fields, I'm all ears. There are also some count fields that serve no purpose within their parent atom. For some reason the format supports splitting a picture into multiple byte ranges, which can be in separate mdats, or separate positions in the same mdat, and there are 3 different ways to address them (I've only implemented the one used in the samples I had). If anyone knows why anyone would ever want to do that, please inform me. This will definitely completely fall apart if any of the metadata atoms come after the iloc. Hopefully that never happens, because it would be a pain to work around. TL;DR this format is bad, but at least we're finally moving past JPEG. --- libavformat/isom.h | 2 + libavformat/mov.c | 331 +++++++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 326 insertions(+), 7 deletions(-) diff --git a/libavformat/isom.h b/libavformat/isom.h index ff009b0896..a3ba10bf76 100644 --- a/libavformat/isom.h +++ b/libavformat/isom.h @@ -223,7 +223,9 @@ typedef struct MOVContext { int found_moov; ///< 'moov' atom has been found int found_mdat; ///< 'mdat' atom has been found int found_hdlr_mdta; ///< 'hdlr' atom with type 'mdta' has been found + int found_iloc; ///< 'iloc' atom has been found int trak_index; ///< Index of the current 'trak' + int cur_stream_index; ///< Stream currently being populated char **meta_keys; unsigned meta_keys_count; DVDemuxContext *dv_demux; diff --git a/libavformat/mov.c b/libavformat/mov.c index 522ce60c2d..87dbc83d6f 100644 --- a/libavformat/mov.c +++ b/libavformat/mov.c @@ -1678,9 +1678,9 @@ static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom) AVStream *st; int ret; - if (c->fc->nb_streams < 1) + if (c->cur_stream_index < 0) return 0; - st = c->fc->streams[c->fc->nb_streams-1]; + st = c->fc->streams[c->cur_stream_index]; if ((uint64_t)atom.size > (1<<30)) return AVERROR_INVALIDDATA; @@ -3742,6 +3742,8 @@ static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom) sc = av_mallocz(sizeof(MOVStreamContext)); if (!sc) return AVERROR(ENOMEM); + c->cur_stream_index = st->index; + st->priv_data = sc; st->codecpar->codec_type = AVMEDIA_TYPE_DATA; sc->ffindex = st->index; @@ -3976,6 +3978,10 @@ static int mov_read_custom(MOVContext *c, AVIOContext *pb, MOVAtom atom) static int mov_read_meta(MOVContext *c, AVIOContext *pb, MOVAtom atom) { + // Skip version and flags + avio_skip(pb, 4); + atom.size -= 4; + while (atom.size > 8) { uint32_t tag = avio_rl32(pb); atom.size -= 4; @@ -5470,6 +5476,310 @@ static int mov_read_dops(MOVContext *c, AVIOContext *pb, MOVAtom atom) return 0; } +static uint64_t read_length(AVIOContext *pb, unsigned len) +{ + uint64_t ret = 0, i = 0; + for (i = 0; i < len; i++) + ret = (ret << 8) | avio_r8(pb); + return ret; +} + +enum HEIFOffsetType { + HEIF_OFFSET_FILE = 0, + HEIF_OFFSET_MDAT = 1, + HEIF_OFFSET_ITEM = 2 +}; + +static int mov_read_iloc(MOVContext *c, AVIOContext *pb, MOVAtom atom) +{ + int version = avio_r8(pb); + avio_rb24(pb); // flags + int ret = 0; + + unsigned item_count, i, j; + + int offset_size = avio_r8(pb); + int length_size = offset_size & 0xf; + int base_offset_size = avio_r8(pb); + int index_size = base_offset_size & 0xf; + offset_size >>= 4; + base_offset_size >>= 4; + + if (version > 2) { + avpriv_request_sample(c->fc, "iloc atom Version %d", version); + return AVERROR_PATCHWELCOME; + } + + if (offset_size > 8 || length_size > 8 || base_offset_size > 8 || index_size > 8) { + avpriv_request_sample(c->fc, ">8-byte sizes in iloc"); + return AVERROR_PATCHWELCOME; + } + + item_count = (version < 2) ? avio_rb16(pb) : avio_rb32(pb); + + for (i = 0; i < item_count; i++) { + int64_t base_offset; + int data_ref_index, nb_extents; + enum HEIFOffsetType offset_type = 0; + + MOVStreamContext *sc; + AVStream *st = avformat_new_stream(c->fc, NULL); + if (!st) + return AVERROR(ENOMEM); + sc = av_mallocz(sizeof(*sc)); + if (!sc) + return AVERROR(ENOMEM); + st->priv_data = sc; + + st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO; + st->disposition |= AV_DISPOSITION_ATTACHED_PIC; + + st->id = (version < 2) ? avio_rb16(pb) : (int)avio_rb32(pb); + + if (version > 0) { + avio_r8(pb); // reserved + offset_type = avio_r8(pb) & 0xf; + } + + if (offset_type != HEIF_OFFSET_FILE) { + avpriv_request_sample(c->fc, "iloc offset type %d", offset_type); + return AVERROR_PATCHWELCOME; + } + + data_ref_index = avio_rb16(pb); + base_offset = read_length(pb, base_offset_size); + nb_extents = avio_rb16(pb); + + for (j = 0; j < nb_extents; j++) { + int64_t pos = 0; + int64_t old_pos; + int64_t ret64; + int64_t ext_index = 0, ext_offset, ext_len; + if (version > 0) + ext_index = read_length(pb, index_size); + ext_offset = read_length(pb, offset_size); + ext_len = read_length(pb, length_size); + + if (offset_type == HEIF_OFFSET_FILE) { + pos = base_offset + ext_offset; + } + + //FIXME: this will thrash badly if there are lots of extents or lots of items + old_pos = avio_tell(pb); + if ((ret64 = avio_seek(pb, pos, SEEK_SET)) < 0) { + ret = (int)ret64; + goto err; + } + + if ((ret = av_append_packet(pb, &st->attached_pic, ext_len)) < 0) + goto err; + + if ((ret64 = avio_seek(pb, old_pos, SEEK_SET)) < 0) { + ret = (int)ret64; + goto err; + } + } + + st->attached_pic.stream_index = st->index; + st->attached_pic.flags |= AV_PKT_FLAG_KEY; + +err: + if (ret < 0) { + av_packet_unref(&st->attached_pic); + break; + } + } + + if (ret >= 0) + c->found_iloc = 1; + + return ret; +} + +static int mov_read_iinf(MOVContext *c, AVIOContext *pb, MOVAtom atom) +{ + int version = avio_r8(pb); + avio_rb24(pb); // flags + + atom.size -= 4; + + // Completely useless entry count + if (version > 0) { + avio_rb32(pb); + atom.size -= 4; + } else { + avio_rb16(pb); + atom.size -= 2; + } + + return mov_read_default(c, pb, atom); +} + +static int mov_read_infe(MOVContext *c, AVIOContext *pb, MOVAtom atom) +{ + AVStream *st = NULL; + int codec_tag; + int stream_id, i; + int version = avio_r8(pb); + avio_rb24(pb); // flags + + stream_id = (version >= 3) ? avio_rb32(pb) : avio_rb16(pb); + + for (i = 0; i < c->fc->nb_streams; i++) { + if (c->fc->streams[i]->id == stream_id) { + st = c->fc->streams[i]; + break; + } + } + + if (!st) + return AVERROR_INVALIDDATA; + + if (avio_rb16(pb) != 0) { + avpriv_request_sample(c->fc, "protected HEIF"); + return AVERROR_PATCHWELCOME; + } + + codec_tag = avio_rl32(pb); + st->codecpar->codec_id = mov_codec_id(st, codec_tag); + + //FIXME: there may be more information here; no samples I've seen use it + return 0; +} + +static int mov_read_iprp(MOVContext *c, AVIOContext *pb, MOVAtom atom) +{ + typedef struct AtomPos { + int64_t pos; + int64_t size; + } AtomPos; + int version, flags; + unsigned count, i, j; + AtomPos *atoms = NULL; + int nb_atoms = 0; + int ret = 0; + int64_t ret64; + int64_t old_pos; + + MOVAtom a; + a.size = avio_rb32(pb); + a.type = avio_rl32(pb); + + if (a.size < 8 || a.type != MKTAG('i','p','c','o')) + return AVERROR_INVALIDDATA; + + a.size -= 8; + + while (a.size >= 8) { + AtomPos *ref = av_dynarray2_add((void**)&atoms, &nb_atoms, sizeof(AtomPos), NULL); + if (!ref) { + ret = AVERROR(ENOMEM); + goto fail; + } + ref->pos = avio_tell(pb); + ref->size = avio_rb32(pb); + if (ref->size > a.size || ref->size < 8) + break; + if ((ret64 = avio_seek(pb, ref->pos + ref->size, SEEK_SET)) < 0) { + ret = ret64; + goto fail; + } + a.size -= ref->size; + } + + if (a.size) { + ret = AVERROR_INVALIDDATA; + goto fail; + } + + a.size = avio_rb32(pb); + a.type = avio_rl32(pb); + + if (a.size < 8 || a.type != MKTAG('i','p','m','a')) { + ret = AVERROR_INVALIDDATA; + goto fail; + } + + version = avio_r8(pb); + flags = avio_rb24(pb); + + count = avio_rb32(pb); + + for (i = 0; i < count; i++) { + int stream_id = (version >= 1) ? avio_rb32(pb) : avio_rb16(pb); + int acount = avio_r8(pb); + + for (j = 0; j < c->fc->nb_streams; j++) { + if (c->fc->streams[j]->id == stream_id) + break; + } + + if (j == c->fc->nb_streams) { + ret = AVERROR_INVALIDDATA; + goto fail; + } + + c->cur_stream_index = j; + + for (j = 0; j < acount; j++) { + MOVAtom parentAtom; + AtomPos *atom; + int index = avio_r8(pb) & 0x7f; + if (flags & 1) { + index <<= 8; + index |= avio_r8(pb); + } + if (index > nb_atoms || index == 0) { + ret = AVERROR_INVALIDDATA; + goto fail; + } + + index--; + + atom = &atoms[index]; + + old_pos = avio_tell(pb); + + if ((ret64 = avio_seek(pb, atom->pos, SEEK_SET)) < 0) { + ret = (int)ret64; + goto fail; + } + + parentAtom = (MOVAtom){ .size = atom->size, .type = MKTAG('i','p','c','o') }; + if ((ret = mov_read_default(c, pb, parentAtom)) < 0) + goto fail; + + if ((ret64 = avio_seek(pb, old_pos, SEEK_SET)) < 0) { + ret = (int)ret64; + goto fail; + } + } + } + + ret = 0; + +fail: + av_free(atoms); + return ret; +} + +static int mov_read_ispe(MOVContext *c, AVIOContext *pb, MOVAtom atom) +{ + AVStream *st; + + if (c->cur_stream_index < 0) + return 0; + st = c->fc->streams[c->cur_stream_index]; + + avio_r8(pb); // version + avio_rb24(pb); // flags + + st->codecpar->width = avio_rb32(pb); + st->codecpar->height = avio_rb32(pb); + + return 0; +} + static const MOVParseTableEntry mov_default_parse_table[] = { { MKTAG('A','C','L','R'), mov_read_aclr }, { MKTAG('A','P','R','G'), mov_read_avid }, @@ -5555,6 +5865,11 @@ static const MOVParseTableEntry mov_default_parse_table[] = { { MKTAG('S','m','D','m'), mov_read_smdm }, { MKTAG('C','o','L','L'), mov_read_coll }, { MKTAG('v','p','c','C'), mov_read_vpcc }, +{ MKTAG('i','l','o','c'), mov_read_iloc }, +{ MKTAG('i','i','n','f'), mov_read_iinf }, +{ MKTAG('i','n','f','e'), mov_read_infe }, +{ MKTAG('i','p','r','p'), mov_read_iprp }, +{ MKTAG('i','s','p','e'), mov_read_ispe }, { 0, NULL } }; @@ -5701,6 +6016,7 @@ static int mov_probe(AVProbeData *p) case MKTAG('p','n','o','t'): /* detect movs with preview pics like ew.mov and april.mov */ case MKTAG('u','d','t','a'): /* Packet Video PVAuthor adds this and a lot of more junk */ case MKTAG('f','t','y','p'): + case MKTAG('i','l','o','c'): if (AV_RB32(p->buf+offset) < 8 && (AV_RB32(p->buf+offset) != 1 || offset + 12 > (unsigned int)p->buf_size || @@ -6167,6 +6483,7 @@ static int mov_read_header(AVFormatContext *s) mov->fc = s; mov->trak_index = -1; + mov->cur_stream_index = -1; /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */ if (pb->seekable & AVIO_SEEKABLE_NORMAL) atom.size = avio_size(pb); @@ -6182,8 +6499,8 @@ static int mov_read_header(AVFormatContext *s) mov_read_close(s); return err; } - } while ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !mov->found_moov && !mov->moov_retry++); - if (!mov->found_moov) { + } while ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !mov->found_moov && !mov->found_iloc && !mov->moov_retry++); + if (!mov->found_moov && !mov->found_iloc) { av_log(s, AV_LOG_ERROR, "moov atom not found\n"); mov_read_close(s); return AVERROR_INVALIDDATA; @@ -6767,18 +7084,18 @@ static const AVOption mov_options[] = { }; static const AVClass mov_class = { - .class_name = "mov,mp4,m4a,3gp,3g2,mj2", + .class_name = "mov,mp4,m4a,3gp,3g2,mj2,heif,heic", .item_name = av_default_item_name, .option = mov_options, .version = LIBAVUTIL_VERSION_INT, }; AVInputFormat ff_mov_demuxer = { - .name = "mov,mp4,m4a,3gp,3g2,mj2", + .name = "mov,mp4,m4a,3gp,3g2,mj2,heif,heic", .long_name = NULL_IF_CONFIG_SMALL("QuickTime / MOV"), .priv_class = &mov_class, .priv_data_size = sizeof(MOVContext), - .extensions = "mov,mp4,m4a,3gp,3g2,mj2", + .extensions = "mov,mp4,m4a,3gp,3g2,mj2,heif,heic", .read_probe = mov_probe, .read_header = mov_read_header, .read_packet = mov_read_packet, -- 2.14.1

4 12

[PATCH] mpegvideo_enc: add option to disable intra mbs in p frames
by Ramiro Polla 24 Oct '19

24 Oct '19

This option prevents the mpv encoders from using intra macroblocks in predictive frames. It is useful for glitch artists to generate input material. This option allows them to split and merge two video files while maintaining fluid motion from the second video without having intra macroblocks restoring chunks of the first video. --- libavcodec/motion_est.c | 4 ++-- libavcodec/mpegvideo.h | 2 ++ libavcodec/mpegvideo_enc.c | 5 +++-- 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/libavcodec/motion_est.c b/libavcodec/motion_est.c index 8b5ce2117a..827e2282f7 100644 --- a/libavcodec/motion_est.c +++ b/libavcodec/motion_est.c @@ -971,7 +971,7 @@ void ff_estimate_p_frame_motion(MpegEncContext * s, int i_score= varc-500+(s->lambda2>>FF_LAMBDA_SHIFT)*20; c->scene_change_score+= ff_sqrt(p_score) - ff_sqrt(i_score); - if (vard*2 + 200*256 > varc) + if (vard*2 + 200*256 > varc && !(s->mpv_flags & FF_MPV_FLAG_NOPIMB)) mb_type|= CANDIDATE_MB_TYPE_INTRA; if (varc*2 + 200*256 > vard || s->qscale > 24){ // if (varc*2 + 200*256 + 50*(s->lambda2>>FF_LAMBDA_SHIFT) > vard){ @@ -1042,7 +1042,7 @@ void ff_estimate_p_frame_motion(MpegEncContext * s, } intra_score += c->mb_penalty_factor*16; - if(intra_score < dmin){ + if(intra_score < dmin && !(s->mpv_flags & FF_MPV_FLAG_NOPIMB)){ mb_type= CANDIDATE_MB_TYPE_INTRA; s->current_picture.mb_type[mb_y*s->mb_stride + mb_x] = CANDIDATE_MB_TYPE_INTRA; //FIXME cleanup }else diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h index e16deb64e7..b7ac2c7b48 100644 --- a/libavcodec/mpegvideo.h +++ b/libavcodec/mpegvideo.h @@ -586,6 +586,7 @@ typedef struct MpegEncContext { #define FF_MPV_FLAG_CBP_RD 0x0008 #define FF_MPV_FLAG_NAQ 0x0010 #define FF_MPV_FLAG_MV0 0x0020 +#define FF_MPV_FLAG_NOPIMB 0x0040 #define FF_MPV_OPT_CMP_FUNC \ { "sad", "Sum of absolute differences, fast", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_SAD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \ @@ -617,6 +618,7 @@ FF_MPV_OPT_CMP_FUNC, \ { "cbp_rd", "use rate distortion optimization for CBP", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_CBP_RD }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\ { "naq", "normalize adaptive quantization", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_NAQ }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\ { "mv0", "always try a mb with mv=<0,0>", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_MV0 }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\ +{ "nopimb", "do not use intra mbs for predictive frames", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_NOPIMB }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\ { "luma_elim_threshold", "single coefficient elimination threshold for luminance (negative values also consider dc coefficient)",\ FF_MPV_OFFSET(luma_elim_threshold), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },\ { "chroma_elim_threshold", "single coefficient elimination threshold for chrominance (negative values also consider dc coefficient)",\ diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c index 9fdab31a25..e41a8f40cf 100644 --- a/libavcodec/mpegvideo_enc.c +++ b/libavcodec/mpegvideo_enc.c @@ -3752,6 +3752,7 @@ static int encode_picture(MpegEncContext *s, int picture_number) if(!s->umvplus){ if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) { + int truncate = s->mpv_flags & FF_MPV_FLAG_NOPIMB; s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER); if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) { @@ -3762,13 +3763,13 @@ static int encode_picture(MpegEncContext *s, int picture_number) } ff_fix_long_p_mvs(s); - ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0); + ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, truncate); if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) { int j; for(i=0; i<2; i++){ for(j=0; j<2; j++) ff_fix_long_mvs(s, s->p_field_select_table[i], j, - s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0); + s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, truncate); } } } -- 2.11.0

2 6

[PATCH] lavf/mpegts: add support for AVS2
by hwren 18 Sep '19

18 Sep '19

Signed-off-by: hwren <hwrenx(a)126.com> --- libavformat/mpegts.c | 1 + libavformat/mpegts.h | 1 + 2 files changed, 2 insertions(+) diff --git a/libavformat/mpegts.c b/libavformat/mpegts.c index 5f53f77..6674cd0 100644 --- a/libavformat/mpegts.c +++ b/libavformat/mpegts.c @@ -735,6 +735,7 @@ static const StreamType ISO_types[] = { { 0x21, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_JPEG2000 }, { 0x24, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_HEVC }, { 0x42, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_CAVS }, + { 0xd2, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_AVS2 }, { 0xd1, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC }, { 0xea, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 }, { 0 }, diff --git a/libavformat/mpegts.h b/libavformat/mpegts.h index 272e2be..b37db3c 100644 --- a/libavformat/mpegts.h +++ b/libavformat/mpegts.h @@ -55,6 +55,7 @@ #define STREAM_TYPE_VIDEO_H264 0x1b #define STREAM_TYPE_VIDEO_HEVC 0x24 #define STREAM_TYPE_VIDEO_CAVS 0x42 +#define STREAM_TYPE_VIDEO_AVS2 0xd2 #define STREAM_TYPE_VIDEO_VC1 0xea #define STREAM_TYPE_VIDEO_DIRAC 0xd1 -- 2.7.4

2 2

[PATCH 1/7] lavf: add cue sheet demuxer
by Rodger Combs 23 Aug '19

23 Aug '19

--- Changelog | 2 + doc/demuxers.texi | 8 ++ libavformat/Makefile | 1 + libavformat/allformats.c | 1 + libavformat/cuedec.c | 215 +++++++++++++++++++++++++++++++++++++++++++++++ libavformat/version.h | 2 +- 6 files changed, 228 insertions(+), 1 deletion(-) create mode 100644 libavformat/cuedec.c diff --git a/Changelog b/Changelog index 187ae79..6701d30 100644 --- a/Changelog +++ b/Changelog @@ -29,6 +29,8 @@ version <next>: - limiter video filter - libvmaf video filter - Dolby E decoder and SMPTE 337M demuxer +- Cue sheet demuxer + version 3.3: - CrystalHD decoder moved to new decode API diff --git a/doc/demuxers.texi b/doc/demuxers.texi index 29a23d4..7ea4f27 100644 --- a/doc/demuxers.texi +++ b/doc/demuxers.texi @@ -244,6 +244,14 @@ file subdir/file-2.wav @end example @end itemize +@section cue + +Cue sheet demuxer. + +This demuxer reads a cue sheet (text file) and exports its track listing in +the form of AVChapters. Packet data is read from the file listed in the sheet. +To override the path the packet data is read from, use the @code{url} option. + @section flv, live_flv Adobe Flash Video Format demuxer. diff --git a/libavformat/Makefile b/libavformat/Makefile index b0ef82c..4381c42 100644 --- a/libavformat/Makefile +++ b/libavformat/Makefile @@ -130,6 +130,7 @@ OBJS-$(CONFIG_CDXL_DEMUXER) += cdxl.o OBJS-$(CONFIG_CINE_DEMUXER) += cinedec.o OBJS-$(CONFIG_CONCAT_DEMUXER) += concatdec.o OBJS-$(CONFIG_CRC_MUXER) += crcenc.o +OBJS-$(CONFIG_CUE_DEMUXER) += cuedec.o OBJS-$(CONFIG_DATA_DEMUXER) += rawdec.o OBJS-$(CONFIG_DATA_MUXER) += rawenc.o OBJS-$(CONFIG_DASH_MUXER) += dashenc.o diff --git a/libavformat/allformats.c b/libavformat/allformats.c index 1ebc142..25afa8b 100644 --- a/libavformat/allformats.c +++ b/libavformat/allformats.c @@ -96,6 +96,7 @@ static void register_all(void) REGISTER_DEMUXER (CINE, cine); REGISTER_DEMUXER (CONCAT, concat); REGISTER_MUXER (CRC, crc); + REGISTER_DEMUXER (CUE, cue); REGISTER_MUXER (DASH, dash); REGISTER_MUXDEMUX(DATA, data); REGISTER_MUXDEMUX(DAUD, daud); diff --git a/libavformat/cuedec.c b/libavformat/cuedec.c new file mode 100644 index 0000000..d0dcac4 --- /dev/null +++ b/libavformat/cuedec.c @@ -0,0 +1,215 @@ +/* + * Cue sheet demuxer + * Copyright (c) 2016 The FFmpeg Project + * + * 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 + * Cue sheet demuxer + * @author Rodger Combs <rodger.combs(a)gmail.com> + */ + +#include "avformat.h" +#include "internal.h" +#include "subtitles.h" +#include "url.h" +#include "libavutil/intreadwrite.h" +#include "libavutil/avstring.h" +#include "libavutil/opt.h" + +typedef struct CueDemuxContext { + AVClass *class; + char *url; + AVFormatContext *avf; +} CueDemuxContext; + +static int cue_probe(AVProbeData *p) +{ + const unsigned char *ptr = p->buf; + + if (AV_RB24(ptr) == 0xEFBBBF) + ptr += 3; /* skip UTF-8 BOM */ + while (*ptr && strncmp(ptr, "FILE ", 5)) + ptr += ff_subtitles_next_line(ptr); + if (!strncmp(ptr, "FILE ", 5)) + return AVPROBE_SCORE_MAX - 5; + return 0; +} + +static char *get_token(char *in) +{ + char *end; + while (av_isspace(*in)) + in++; + if (*in == '"') { + in++; + end = in + strcspn(in, "\"\n\t\r"); + } else { + end = in + strcspn(in, " \n\t\r"); + } + *end = '\0'; + return in; +} + +static int cue_read_header(AVFormatContext *s) +{ + int ret, i; + CueDemuxContext *cue = s->priv_data; + char line[4096], *ptr; + AVDictionary **meta = &s->metadata; + AVChapter *chap = NULL; + while (ff_get_line(s->pb, line, sizeof(line))) { + ptr = line; + if (AV_RB24(ptr) == 0xEFBBBF) + ptr += 3; /* skip UTF-8 BOM */ + while (*ptr == ' ' || *ptr == '\t') + ptr++; + if (!strncmp(ptr, "REM ", 4)) { + char *end = ptr + strcspn(ptr, "\r\n"); + *end = '\0'; + av_log(s, AV_LOG_INFO, "Comment: \"%s\"\n", ptr + 4); + } else if (!strncmp(ptr, "TITLE ", 6)) { + ptr = get_token(ptr + 6); + av_dict_set(meta, chap ? "title" : "album", ptr, 0); + } else if (!strncmp(ptr, "PERFORMER ", 10)) { + ptr = get_token(ptr + 10); + av_dict_set(meta, chap ? "artist" : "album_artist", ptr, 0); + } else if (!strncmp(ptr, "FILE ", 5)) { + if (!cue->url || !*cue->url) { + const char *filename = get_token(ptr + 5); + char url[4096] = {0}; + + if (filename[strcspn(filename, "/\\:")] != 0) { + av_log(s, AV_LOG_ERROR, "Only bare filenames are allowed in cue FILE directives.\n" + "To read from '%s', use the 'url' option explicitly.", filename); + return AVERROR_INVALIDDATA; + } + + av_freep(&cue->url); + ff_make_absolute_url(url, sizeof(url), s->filename, filename); + if (!(cue->url = av_strdup(url))) + return AVERROR(ENOMEM); + } + } else if (!strncmp(ptr, "TRACK ", 6)) { + int index = strtol(ptr + 6, &ptr, 10); + chap = avpriv_new_chapter(s, index, (AVRational){1, 75}, AV_NOPTS_VALUE, AV_NOPTS_VALUE, NULL); + if (!chap) + return AVERROR(ENOMEM); + meta = &chap->metadata; + if ((ret = av_dict_copy(meta, s->metadata, 0)) < 0) + return ret; + av_dict_set_int(meta, "track", index, 0); + } else if (!strncmp(ptr, "INDEX ", 6)) { + int min, sec, frame; + int index = strtol(ptr + 6, &ptr, 10); + if (!chap) + return AVERROR_INVALIDDATA; + if (sscanf(ptr, "%u:%u:%u", &min, &sec, &frame) != 3) + return AVERROR_INVALIDDATA; + if (index == 1 || chap->start == 0) + chap->start = min * 75 * 60 + sec * 75 + frame; + } else { + av_log(s, AV_LOG_WARNING, "Unknown command: \"%s\"\n", ptr); + } + } + + if (!cue->url || !*cue->url) + return AVERROR_INVALIDDATA; + + if (!(cue->avf = avformat_alloc_context())) + return AVERROR(ENOMEM); + + cue->avf->interrupt_callback = s->interrupt_callback; + if ((ret = ff_copy_whiteblacklists(cue->avf, s)) < 0) + return ret; + + if ((ret = avformat_open_input(&cue->avf, cue->url, NULL, NULL)) < 0 || + (ret = avformat_find_stream_info(cue->avf, NULL)) < 0) { + av_log(s, AV_LOG_ERROR, "Failed to open '%s'\n", cue->url); + avformat_close_input(&cue->avf); + return ret; + } + + ff_read_frame_flush(cue->avf); + + for (i = 0; i < cue->avf->nb_streams; i++) { + AVStream *st = avformat_new_stream(s, NULL); + AVStream *ist = cue->avf->streams[i]; + if (!st) + return AVERROR(ENOMEM); + st->id = i; + + avcodec_parameters_copy(st->codecpar, ist->codecpar); + + st->disposition = ist->disposition; + avpriv_set_pts_info(st, ist->pts_wrap_bits, ist->time_base.num, ist->time_base.den); + av_copy_packet(&st->attached_pic, &ist->attached_pic); + } + + s->duration = cue->avf->duration; + + return 0; +} + +static int cue_read_packet(AVFormatContext *s, AVPacket *pkt) +{ + CueDemuxContext *cue = s->priv_data; + return av_read_frame(cue->avf, pkt); +} + +static int cue_read_seek(AVFormatContext *s, int stream_index, + int64_t min_ts, int64_t ts, int64_t max_ts, int flags) +{ + CueDemuxContext *cue = s->priv_data; + return avformat_seek_file(cue->avf, stream_index, min_ts, ts, max_ts, flags); +} + +static int cue_read_close(AVFormatContext *s) +{ + CueDemuxContext *cue = s->priv_data; + avformat_close_input(&cue->avf); + return 0; +} + +#define OFFSET(x) offsetof(CueDemuxContext, x) +#define E AV_OPT_FLAG_DECODING_PARAM +static const AVOption options[] = { + { "url", "override underlying audio location", OFFSET(url), AV_OPT_TYPE_STRING, {.str = ""}, CHAR_MIN, CHAR_MAX, E }, + { NULL } +}; + +static const AVClass cue_class = { + .class_name = "Cue sheet demuxer", + .item_name = av_default_item_name, + .option = options, + .version = LIBAVUTIL_VERSION_INT, +}; + +AVInputFormat ff_cue_demuxer = { + .name = "cue", + .long_name = NULL_IF_CONFIG_SMALL("Cue sheet"), + .extensions = "cue", + .priv_data_size = sizeof(CueDemuxContext), + .read_probe = cue_probe, + .read_header = cue_read_header, + .read_packet = cue_read_packet, + .read_seek2 = cue_read_seek, + .read_close = cue_read_close, + .priv_class = &cue_class, +}; diff --git a/libavformat/version.h b/libavformat/version.h index 48b81f2..a8cf4c1 100644 --- a/libavformat/version.h +++ b/libavformat/version.h @@ -32,7 +32,7 @@ // Major bumping may affect Ticket5467, 5421, 5451(compatibility with Chromium) // Also please add any ticket numbers that you believe might be affected here #define LIBAVFORMAT_VERSION_MAJOR 57 -#define LIBAVFORMAT_VERSION_MINOR 76 +#define LIBAVFORMAT_VERSION_MINOR 77 #define LIBAVFORMAT_VERSION_MICRO 100 #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \ -- 2.6.4

7 22

[PATCH 1/2] avcodec/mlpenc: encode last frame too
by Paul B Mahol 09 Aug '19

09 Aug '19

Signed-off-by: Paul B Mahol <onemda(a)gmail.com> --- libavcodec/mlpenc.c | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/libavcodec/mlpenc.c b/libavcodec/mlpenc.c index 7536d3b2f5..c588f5b904 100644 --- a/libavcodec/mlpenc.c +++ b/libavcodec/mlpenc.c @@ -2225,29 +2225,27 @@ static int mlp_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, int restart_frame, ret; uint8_t *data; - if ((ret = ff_alloc_packet2(avctx, avpkt, 87500 * avctx->channels, 0)) < 0) - return ret; - - if (!frame) - return 1; - /* add current frame to queue */ if (frame) { if ((ret = ff_af_queue_add(&ctx->afq, frame)) < 0) return ret; + } else { + if (ctx->last_frame == ctx->inout_buffer) { + return 0; + } } - data = frame->data[0]; + + if ((ret = ff_alloc_packet2(avctx, avpkt, 87500 * avctx->channels, 0)) < 0) + return ret; + + data = frame ? frame->data[0] : NULL; ctx->frame_index = avctx->frame_number % ctx->max_restart_interval; ctx->inout_buffer = ctx->major_inout_buffer + ctx->frame_index * ctx->one_sample_buffer_size; - if (ctx->last_frame == ctx->inout_buffer) { - return 0; - } - ctx->sample_buffer = ctx->major_scratch_buffer + ctx->frame_index * ctx->one_sample_buffer_size; @@ -2333,6 +2331,8 @@ input_and_return: number_of_samples += ctx->frame_size[(ctx->starting_frame_index + index) % ctx->max_restart_interval]; } ctx->number_of_samples = number_of_samples; + if (!ctx->number_of_samples) + break; for (index = 0; index < ctx->seq_size[seq_index]; index++) { clear_channel_params(ctx, ctx->seq_channel_params + index*(ctx->avctx->channels)); -- 2.11.0

3 6

[PATCH 1/5] cbs: Add some common code for read/write of miscellaneous user data
by Mark Thompson 27 Jul '19

27 Jul '19

Supports closed captions, active format and bar data as defined by SCTE 128 part 1 or A/53 part 4, suitable for use with both MPEG-2 and H.264. --- libavcodec/cbs_misc.c | 216 ++++++++++++++++++++++++++++++++++ libavcodec/cbs_misc.h | 109 +++++++++++++++++ libavcodec/cbs_misc_syntax_template.c | 150 +++++++++++++++++++++++ 3 files changed, 475 insertions(+) create mode 100644 libavcodec/cbs_misc.c create mode 100644 libavcodec/cbs_misc.h create mode 100644 libavcodec/cbs_misc_syntax_template.c diff --git a/libavcodec/cbs_misc.c b/libavcodec/cbs_misc.c new file mode 100644 index 0000000000..cdf01fe229 --- /dev/null +++ b/libavcodec/cbs_misc.c @@ -0,0 +1,216 @@ +/* + * 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 + */ + +#include "libavutil/attributes.h" +#include "libavutil/avassert.h" + +#include "cbs.h" +#include "cbs_internal.h" +#include "cbs_misc.h" + +#define CHECK(call) do { \ + err = (call); \ + if (err < 0) \ + return err; \ + } while (0) + +#define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name +#define FUNC_MISC(rw, name) FUNC_NAME(rw, misc, name) +#define FUNC(name) FUNC_MISC(READWRITE, name) + + +#define READWRITE read +#define RWContext GetBitContext + +#define xui(width, name, var) do { \ + uint32_t value = 0; \ + CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \ + &value, 0, MAX_UINT_BITS(width))); \ + var = value; \ + } while (0) + +#define ui(width, name) \ + xui(width, name, current->name) + +#define fixed(width, name, expected) do { \ + av_unused uint32_t value; \ + CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, &value, \ + expected, expected)); \ + } while (0) + +#include "cbs_misc_syntax_template.c" + +#undef READWRITE +#undef RWContext +#undef xui +#undef ui +#undef fixed + + +#define READWRITE write +#define RWContext PutBitContext + +#define xui(width, name, var) do { \ + CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \ + var, 0, MAX_UINT_BITS(width))); \ + } while (0) + +#define ui(width, name) \ + xui(width, name, current->name) + +#define fixed(width, name, value) do { \ + CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, value, \ + value, value)); \ + } while (0) + +#include "cbs_misc_syntax_template.c" + +#undef READWRITE +#undef RWContext +#undef xui +#undef ui +#undef fixed + + +int ff_cbs_read_a53_user_data(CodedBitstreamContext *ctx, + A53UserData *data, + const uint8_t *read_buffer, size_t length) +{ + GetBitContext gbc; + int err; + + err = init_get_bits(&gbc, read_buffer, 8 * length); + if (err < 0) + return err; + + return cbs_misc_read_a53_user_data(ctx, &gbc, data); +} + +int ff_cbs_write_a53_user_data(CodedBitstreamContext *ctx, + uint8_t *write_buffer, size_t *length, + A53UserData *data) +{ + PutBitContext pbc; + int err; + + init_put_bits(&pbc, write_buffer, *length); + + err = cbs_misc_write_a53_user_data(ctx, &pbc, data); + if (err < 0) { + // Includes AVERROR(ENOSPC). + return err; + } + + // That output must be aligned. + av_assert0(put_bits_count(&pbc) % 8 == 0); + + *length = put_bits_count(&pbc) / 8; + + flush_put_bits(&pbc); + + return 0; +} + +int ff_cbs_read_a53_cc_side_data(CodedBitstreamContext *ctx, + A53UserData *data, + const uint8_t *side_data, + size_t side_data_size) +{ + GetBitContext gbc; + CEA708CCData *cc; + int err, i, cc_count; + + if (side_data_size % 3) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "A53 CC side data length must " + "be a multiple of 3 (got %zu).\n", side_data_size); + return AVERROR(EINVAL); + } + cc_count = side_data_size / 3; + if (cc_count > 31) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "A53 CC can only fit 31 packets " + "in a single user data block (got %d).\n", cc_count); + return AVERROR(EINVAL); + } + + *data = (A53UserData) { + .user_identifier = A53_USER_IDENTIFIER_ATSC, + + .atsc = { + .user_data_type_code = A53_USER_DATA_TYPE_CODE_CC_DATA, + + .cc_data = { + .process_em_data_flag = 0, + .process_cc_data_flag = 1, + .additional_data_flag = 0, + + .em_data = 0, + + .cc_count = cc_count, + }, + }, + }; + cc = &data->atsc.cc_data; + + err = init_get_bits(&gbc, side_data, 8 * side_data_size); + if (err < 0) + return err; + + for (i = 0; i < cc->cc_count; i++) { + err = cbs_misc_read_cea708_cc_data_packet(ctx, &gbc, + &cc->cc_data_pkts[i]); + if (err < 0) + return err; + } + + return 0; +} + +int ff_cbs_write_a53_cc_side_data(CodedBitstreamContext *ctx, + uint8_t **side_data, + size_t *side_data_size, + A53UserData *data) +{ + PutBitContext pbc; + CEA708CCData *cc; + int err, i; + + if (data->user_identifier != A53_USER_IDENTIFIER_ATSC || + data->atsc.user_data_type_code != A53_USER_DATA_TYPE_CODE_CC_DATA) + return AVERROR(EINVAL); + + cc = &data->atsc.cc_data; + + err = av_reallocp(side_data, *side_data_size + 3 * cc->cc_count); + if (err < 0) + return err; + + init_put_bits(&pbc, *side_data + *side_data_size, 3 * cc->cc_count); + + for (i = 0; i < cc->cc_count; i++) { + err = cbs_misc_write_cea708_cc_data_packet(ctx, &pbc, + &cc->cc_data_pkts[i]); + if (err < 0) { + av_freep(side_data); + return err; + } + } + + *side_data_size += 3 * cc->cc_count; + + return 0; +} diff --git a/libavcodec/cbs_misc.h b/libavcodec/cbs_misc.h new file mode 100644 index 0000000000..0d7ab2c8e7 --- /dev/null +++ b/libavcodec/cbs_misc.h @@ -0,0 +1,109 @@ +/* + * 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 + */ + +#ifndef AVCODEC_CBS_MISC_H +#define AVCODEC_CBS_MISC_H + +#include <stddef.h> +#include <stdint.h> + +#include "libavutil/common.h" + + +enum { + A53_USER_IDENTIFIER_ATSC = MKBETAG('G', 'A', '9', '4'), + A53_USER_IDENTIFIER_AFD = MKBETAG('D', 'T', 'G', '1'), +}; + +enum { + A53_USER_DATA_TYPE_CODE_CC_DATA = 0x03, + A53_USER_DATA_TYPE_CODE_BAR_DATA = 0x06, +}; + +typedef struct A53BarData { + uint8_t top_bar_flag; + uint8_t bottom_bar_flag; + uint8_t left_bar_flag; + uint8_t right_bar_flag; + + uint16_t line_number_end_of_top_bar; + uint16_t line_number_end_of_bottom_bar; + uint16_t line_number_end_of_left_bar; + uint16_t line_number_end_of_right_bar; +} A53BarData; + +typedef struct CEA708CCDataPacket { + uint8_t cc_valid; + uint8_t cc_type; + uint8_t cc_data_1; + uint8_t cc_data_2; +} CEA708CCDataPacket; + +typedef struct CEA708CCData { + uint8_t process_em_data_flag; + uint8_t process_cc_data_flag; + uint8_t additional_data_flag; + + uint8_t em_data; + + uint8_t cc_count; + CEA708CCDataPacket cc_data_pkts[31]; +} CEA708CCData; + +typedef struct A53ATSCUserData { + uint8_t user_data_type_code; + union { + CEA708CCData cc_data; + A53BarData bar_data; + }; +} A53ATSCUserData; + +typedef struct A53AFDData { + uint8_t active_format_flag; + uint8_t active_format; +} A53AFDData; + +typedef struct A53UserData { + uint32_t user_identifier; + union { + A53ATSCUserData atsc; + A53AFDData afd; + }; +} A53UserData; + + +int ff_cbs_read_a53_user_data(CodedBitstreamContext *ctx, + A53UserData *data, + const uint8_t *read_buffer, size_t length); + +int ff_cbs_write_a53_user_data(CodedBitstreamContext *ctx, + uint8_t *write_buffer, size_t *length, + A53UserData *data); + +int ff_cbs_read_a53_cc_side_data(CodedBitstreamContext *ctx, + A53UserData *data, + const uint8_t *side_data, + size_t side_data_size); + +int ff_cbs_write_a53_cc_side_data(CodedBitstreamContext *ctx, + uint8_t **side_data, + size_t *side_data_length, + A53UserData *data); + + +#endif /* AVCODEC_CBS_MISC_H */ diff --git a/libavcodec/cbs_misc_syntax_template.c b/libavcodec/cbs_misc_syntax_template.c new file mode 100644 index 0000000000..7b98c7cc85 --- /dev/null +++ b/libavcodec/cbs_misc_syntax_template.c @@ -0,0 +1,150 @@ +/* + * 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 + */ + +static int FUNC(a53_bar_data)(CodedBitstreamContext *ctx, RWContext *rw, + A53BarData *current) +{ + int err; + + ui(1, top_bar_flag); + ui(1, bottom_bar_flag); + ui(1, left_bar_flag); + ui(1, right_bar_flag); + fixed(4, reserved, 0xf); + + if (current->top_bar_flag) { + fixed(2, one_bits, 3); + ui(14, line_number_end_of_top_bar); + } + if (current->bottom_bar_flag) { + fixed(2, one_bits, 3); + ui(14, line_number_end_of_bottom_bar); + } + if (current->left_bar_flag) { + fixed(2, one_bits, 3); + ui(14, line_number_end_of_left_bar); + } + if (current->right_bar_flag) { + fixed(2, one_bits, 3); + ui(14, line_number_end_of_right_bar); + } + + return 0; +} + +static int FUNC(cea708_cc_data_packet)(CodedBitstreamContext *ctx, + RWContext *rw, + CEA708CCDataPacket *current) +{ + int err; + + fixed(5, marker_bits, 0x1f); + ui(1, cc_valid); + ui(2, cc_type); + + ui(8, cc_data_1); + ui(8, cc_data_2); + + return 0; +} + +static int FUNC(cea708_cc_data)(CodedBitstreamContext *ctx, RWContext *rw, + CEA708CCData *current) +{ + int err, i; + + ui(1, process_em_data_flag); + ui(1, process_cc_data_flag); + ui(1, additional_data_flag); + + ui(5, cc_count); + + ui(8, em_data); + + for (i = 0; i < current->cc_count; i++) { + CHECK(FUNC(cea708_cc_data_packet)(ctx, rw, + &current->cc_data_pkts[i])); + } + + fixed(8, marker_bits, 0xff); + + if (current->additional_data_flag) { + // Ignored. + } + + return 0; +} + +static int FUNC(a53_atsc_user_data)(CodedBitstreamContext *ctx, RWContext *rw, + A53ATSCUserData *current) +{ + int err; + + ui(8, user_data_type_code); + + switch (current->user_data_type_code) { + case A53_USER_DATA_TYPE_CODE_CC_DATA: + return FUNC(cea708_cc_data)(ctx, rw, &current->cc_data); + case A53_USER_DATA_TYPE_CODE_BAR_DATA: + return FUNC(a53_bar_data)(ctx, rw, &current->bar_data); + default: + av_log(ctx->log_ctx, AV_LOG_WARNING, + "Unknown ATSC user data found: type code %#02x.\n", + current->user_data_type_code); + } + + return 0; +} + +static int FUNC(a53_afd_data)(CodedBitstreamContext *ctx, RWContext *rw, + A53AFDData *current) +{ + int err; + + fixed(1, zero_bit, 0); + ui(1, active_format_flag); + fixed(6, alignment_bits, 1); + + if (current->active_format_flag) { + fixed(4, reserved, 0xf); + ui(4, active_format); + } + + return 0; +} + +static int FUNC(a53_user_data)(CodedBitstreamContext *ctx, RWContext *rw, + A53UserData *current) +{ + int err; + + ui(32, user_identifier); + + switch (current->user_identifier) { + case A53_USER_IDENTIFIER_ATSC: + return FUNC(a53_atsc_user_data)(ctx, rw, &current->atsc); + case A53_USER_IDENTIFIER_AFD: + return FUNC(a53_afd_data)(ctx, rw, &current->afd); + default: + av_log(ctx->log_ctx, AV_LOG_WARNING, + "Unknown registered user data found: identifier %#08x.\n", + current->user_identifier); + } + + return 0; +} -- 2.16.1

5 15

[PATCH] avcodec/qtrle: Do not output duplicated frames on insufficient input
by Michael Niedermayer 05 May '19

05 May '19

This improves performance and makes qtrle behave more similar to other decoders. Libavcodec does generally not output known duplicated frames, instead the calling Application can insert them as it needs. Fixes: Timeout Fixes: 6383/clusterfuzz-testcase-minimized-ffmpeg_AV_CODEC_ID_QTRLE_fuzzer-6199846902956032 Found-by: continuous fuzzing process https://github.com/google/oss-fuzz/tree/master/projects/ffmpeg Signed-off-by: Michael Niedermayer <michael(a)niedermayer.cc> --- libavcodec/qtrle.c | 12 ++--- tests/ref/fate/qtrle-8bit | 109 -------------------------------------- 2 files changed, 6 insertions(+), 115 deletions(-) diff --git a/libavcodec/qtrle.c b/libavcodec/qtrle.c index 1b0d2016b5..670690d0a4 100644 --- a/libavcodec/qtrle.c +++ b/libavcodec/qtrle.c @@ -433,12 +433,10 @@ static int qtrle_decode_frame(AVCodecContext *avctx, int ret; bytestream2_init(&s->g, avpkt->data, avpkt->size); - if ((ret = ff_reget_buffer(avctx, s->frame)) < 0) - return ret; /* check if this frame is even supposed to change */ if (avpkt->size < 8) - goto done; + return avpkt->size; /* start after the chunk size */ bytestream2_seek(&s->g, 4, SEEK_SET); @@ -449,17 +447,20 @@ static int qtrle_decode_frame(AVCodecContext *avctx, /* if a header is present, fetch additional decoding parameters */ if (header & 0x0008) { if (avpkt->size < 14) - goto done; + return avpkt->size; start_line = bytestream2_get_be16(&s->g); bytestream2_skip(&s->g, 2); height = bytestream2_get_be16(&s->g); bytestream2_skip(&s->g, 2); if (height > s->avctx->height - start_line) - goto done; + return avpkt->size; } else { start_line = 0; height = s->avctx->height; } + if ((ret = ff_reget_buffer(avctx, s->frame)) < 0) + return ret; + row_ptr = s->frame->linesize[0] * start_line; switch (avctx->bits_per_coded_sample) { @@ -520,7 +521,6 @@ static int qtrle_decode_frame(AVCodecContext *avctx, memcpy(s->frame->data[1], s->pal, AVPALETTE_SIZE); } -done: if ((ret = av_frame_ref(data, s->frame)) < 0) return ret; *got_frame = 1; diff --git a/tests/ref/fate/qtrle-8bit b/tests/ref/fate/qtrle-8bit index 8da113d83e..27bb8aad71 100644 --- a/tests/ref/fate/qtrle-8bit +++ b/tests/ref/fate/qtrle-8bit @@ -4,169 +4,60 @@ #dimensions 0: 640x480 #sar 0: 0/1 0, 0, 0, 1, 921600, 0x1492e3ed -0, 1, 1, 1, 921600, 0x1492e3ed -0, 2, 2, 1, 921600, 0x1492e3ed 0, 3, 3, 1, 921600, 0x23ef4fc7 -0, 4, 4, 1, 921600, 0x23ef4fc7 0, 5, 5, 1, 921600, 0xe406d4be -0, 6, 6, 1, 921600, 0xe406d4be -0, 7, 7, 1, 921600, 0xe406d4be 0, 8, 8, 1, 921600, 0x62b8b5a1 -0, 9, 9, 1, 921600, 0x62b8b5a1 0, 10, 10, 1, 921600, 0x7d8ba674 -0, 11, 11, 1, 921600, 0x7d8ba674 -0, 12, 12, 1, 921600, 0x7d8ba674 0, 13, 13, 1, 921600, 0xfe666be7 -0, 14, 14, 1, 921600, 0xfe666be7 0, 15, 15, 1, 921600, 0x721baec0 -0, 16, 16, 1, 921600, 0x721baec0 -0, 17, 17, 1, 921600, 0x721baec0 0, 18, 18, 1, 921600, 0xc237180a -0, 19, 19, 1, 921600, 0xc237180a 0, 20, 20, 1, 921600, 0xf03a7482 -0, 21, 21, 1, 921600, 0xf03a7482 -0, 22, 22, 1, 921600, 0xf03a7482 0, 23, 23, 1, 921600, 0x5612a391 -0, 24, 24, 1, 921600, 0x5612a391 0, 25, 25, 1, 921600, 0x9dbcc46a -0, 26, 26, 1, 921600, 0x9dbcc46a -0, 27, 27, 1, 921600, 0x9dbcc46a 0, 28, 28, 1, 921600, 0xa128a5d5 -0, 29, 29, 1, 921600, 0xa128a5d5 0, 30, 30, 1, 921600, 0x63e0025c -0, 31, 31, 1, 921600, 0x63e0025c -0, 32, 32, 1, 921600, 0x63e0025c 0, 33, 33, 1, 921600, 0x262359ed -0, 34, 34, 1, 921600, 0x262359ed 0, 35, 35, 1, 921600, 0x343688e8 -0, 36, 36, 1, 921600, 0x343688e8 -0, 37, 37, 1, 921600, 0x343688e8 -0, 38, 38, 1, 921600, 0x343688e8 -0, 39, 39, 1, 921600, 0x343688e8 -0, 40, 40, 1, 921600, 0x343688e8 -0, 41, 41, 1, 921600, 0x343688e8 -0, 42, 42, 1, 921600, 0x343688e8 -0, 43, 43, 1, 921600, 0x343688e8 -0, 44, 44, 1, 921600, 0x343688e8 0, 45, 45, 1, 921600, 0xe4b29d57 -0, 46, 46, 1, 921600, 0xe4b29d57 -0, 47, 47, 1, 921600, 0xe4b29d57 0, 48, 48, 1, 921600, 0x198e8a4a -0, 49, 49, 1, 921600, 0x198e8a4a 0, 50, 50, 1, 921600, 0x0cad8dc9 -0, 51, 51, 1, 921600, 0x0cad8dc9 -0, 52, 52, 1, 921600, 0x0cad8dc9 0, 53, 53, 1, 921600, 0x1f74cf3d -0, 54, 54, 1, 921600, 0x1f74cf3d 0, 55, 55, 1, 921600, 0xec5b5449 -0, 56, 56, 1, 921600, 0xec5b5449 -0, 57, 57, 1, 921600, 0xec5b5449 0, 58, 58, 1, 921600, 0x39829711 -0, 59, 59, 1, 921600, 0x39829711 0, 60, 60, 1, 921600, 0x6de5b9c6 -0, 61, 61, 1, 921600, 0x6de5b9c6 -0, 62, 62, 1, 921600, 0x6de5b9c6 0, 63, 63, 1, 921600, 0x47b0e9d4 -0, 64, 64, 1, 921600, 0x47b0e9d4 0, 65, 65, 1, 921600, 0x756452b8 -0, 66, 66, 1, 921600, 0x756452b8 -0, 67, 67, 1, 921600, 0x756452b8 0, 68, 68, 1, 921600, 0x6fce3478 -0, 69, 69, 1, 921600, 0x6fce3478 0, 70, 70, 1, 921600, 0x372397cd -0, 71, 71, 1, 921600, 0x372397cd -0, 72, 72, 1, 921600, 0x372397cd 0, 73, 73, 1, 921600, 0xe3999ba1 -0, 74, 74, 1, 921600, 0xe3999ba1 0, 75, 75, 1, 921600, 0x6ba26b43 -0, 76, 76, 1, 921600, 0x6ba26b43 -0, 77, 77, 1, 921600, 0x6ba26b43 0, 78, 78, 1, 921600, 0x4e9ee49e -0, 79, 79, 1, 921600, 0x4e9ee49e 0, 80, 80, 1, 921600, 0xdb5fd6e7 -0, 81, 81, 1, 921600, 0xdb5fd6e7 -0, 82, 82, 1, 921600, 0xdb5fd6e7 0, 83, 83, 1, 921600, 0x8f2254a5 -0, 84, 84, 1, 921600, 0x8f2254a5 -0, 85, 85, 1, 921600, 0x8f2254a5 -0, 86, 86, 1, 921600, 0x8f2254a5 -0, 87, 87, 1, 921600, 0x8f2254a5 -0, 88, 88, 1, 921600, 0x8f2254a5 -0, 89, 89, 1, 921600, 0x8f2254a5 -0, 90, 90, 1, 921600, 0x8f2254a5 -0, 91, 91, 1, 921600, 0x8f2254a5 -0, 92, 92, 1, 921600, 0x8f2254a5 0, 93, 93, 1, 921600, 0x57e95c32 -0, 94, 94, 1, 921600, 0x57e95c32 0, 95, 95, 1, 921600, 0x41627a9b -0, 96, 96, 1, 921600, 0x41627a9b -0, 97, 97, 1, 921600, 0x41627a9b 0, 98, 98, 1, 921600, 0x7412dcee -0, 99, 99, 1, 921600, 0x7412dcee 0, 100, 100, 1, 921600, 0xaebe10ed -0, 101, 101, 1, 921600, 0xaebe10ed -0, 102, 102, 1, 921600, 0xaebe10ed 0, 103, 103, 1, 921600, 0x411a91f6 -0, 104, 104, 1, 921600, 0x411a91f6 0, 105, 105, 1, 921600, 0xb059df3f -0, 106, 106, 1, 921600, 0xb059df3f -0, 107, 107, 1, 921600, 0xb059df3f 0, 108, 108, 1, 921600, 0x4d6f5a77 -0, 109, 109, 1, 921600, 0x4d6f5a77 0, 110, 110, 1, 921600, 0xbbf06df4 -0, 111, 111, 1, 921600, 0xbbf06df4 -0, 112, 112, 1, 921600, 0xbbf06df4 0, 113, 113, 1, 921600, 0xe27f7bf6 -0, 114, 114, 1, 921600, 0xe27f7bf6 0, 115, 115, 1, 921600, 0xd7e8360e -0, 116, 116, 1, 921600, 0xd7e8360e -0, 117, 117, 1, 921600, 0xd7e8360e 0, 118, 118, 1, 921600, 0x1dd4c344 -0, 119, 119, 1, 921600, 0x1dd4c344 0, 120, 120, 1, 921600, 0x7995a7ce -0, 121, 121, 1, 921600, 0x7995a7ce -0, 122, 122, 1, 921600, 0x7995a7ce 0, 123, 123, 1, 921600, 0x2ef3c566 -0, 124, 124, 1, 921600, 0x2ef3c566 0, 125, 125, 1, 921600, 0xf296736e -0, 126, 126, 1, 921600, 0xf296736e -0, 127, 127, 1, 921600, 0xf296736e -0, 128, 128, 1, 921600, 0xf296736e -0, 129, 129, 1, 921600, 0xf296736e -0, 130, 130, 1, 921600, 0xf296736e -0, 131, 131, 1, 921600, 0xf296736e -0, 132, 132, 1, 921600, 0xf296736e -0, 133, 133, 1, 921600, 0xf296736e -0, 134, 134, 1, 921600, 0xf296736e 0, 135, 135, 1, 921600, 0x1a488311 -0, 136, 136, 1, 921600, 0x1a488311 -0, 137, 137, 1, 921600, 0x1a488311 0, 138, 138, 1, 921600, 0x9e28011b -0, 139, 139, 1, 921600, 0x9e28011b 0, 140, 140, 1, 921600, 0x84d1ea80 -0, 141, 141, 1, 921600, 0x84d1ea80 -0, 142, 142, 1, 921600, 0x84d1ea80 0, 143, 143, 1, 921600, 0x9ed41052 -0, 144, 144, 1, 921600, 0x9ed41052 0, 145, 145, 1, 921600, 0xd4db7206 -0, 146, 146, 1, 921600, 0xd4db7206 -0, 147, 147, 1, 921600, 0xd4db7206 0, 148, 148, 1, 921600, 0x55f695a9 -0, 149, 149, 1, 921600, 0x55f695a9 0, 150, 150, 1, 921600, 0x9d8c667f -0, 151, 151, 1, 921600, 0x9d8c667f -0, 152, 152, 1, 921600, 0x9d8c667f 0, 153, 153, 1, 921600, 0x9b6037ec -0, 154, 154, 1, 921600, 0x9b6037ec 0, 155, 155, 1, 921600, 0x57c5e835 -0, 156, 156, 1, 921600, 0x57c5e835 -0, 157, 157, 1, 921600, 0x57c5e835 0, 158, 158, 1, 921600, 0x476dad89 -0, 159, 159, 1, 921600, 0x476dad89 0, 160, 160, 1, 921600, 0xcfd6ad2b -0, 161, 161, 1, 921600, 0xcfd6ad2b -0, 162, 162, 1, 921600, 0xcfd6ad2b 0, 163, 163, 1, 921600, 0x3b372379 -0, 164, 164, 1, 921600, 0x3b372379 0, 165, 165, 1, 921600, 0x36f245f5 -0, 166, 166, 1, 921600, 0x36f245f5 -- 2.17.0

3 3

[MSVC toolchain] Patch to allow building FFmpeg with Linux bash on Windows (WSL)
by Cyber Sinh 24 Apr '19

24 Apr '19

The attached patch changes the configure script for FFmpeg (and associated shell scripts) to call MSVC tools including their extensions (cl.exe instead of cl for example). This is necessary, because WSL can automatically launch Windows processes from the Linux side but only if the process is in the path and includes the full name. Linux doesn't automatically append .exe and such to invoke a file.

8 9

[PATCH]lavf/latmenc: Error out for invalid codecs
by Carl Eugen Hoyos 20 Mar '19

20 Mar '19

Hi! Attached patch makes sure the loas muxer does not try to write anything but aac and latm. Please comment, Carl Eugen

6 20