From patchwork Thu Oct 15 16:45:13 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nachiket Tarate X-Patchwork-Id: 22970 Return-Path: X-Original-To: patchwork@ffaux-bg.ffmpeg.org Delivered-To: patchwork@ffaux-bg.ffmpeg.org Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100]) by ffaux.localdomain (Postfix) with ESMTP id 9F149449623 for ; Thu, 15 Oct 2020 19:45:45 +0300 (EEST) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 70EEB68B9A4; Thu, 15 Oct 2020 19:45:45 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from APC01-HK2-obe.outbound.protection.outlook.com (mail-oln040092255067.outbound.protection.outlook.com [40.92.255.67]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 3EE6E68B7DA for ; Thu, 15 Oct 2020 19:45:38 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=B+toVO849FqusvNWvaXp0Kftuk1iJrljT29wif8TXkCxGL8Tn75usEviDPG4C1/0oMiUGvQC2az4Ukhl0slRgncdNgXK8F6qofOTsP9qJyb3rZTEG3dkIB71Z0S2SCVlzWDIPfqYjJK3xHN8CdLtPYlL6jlEkDsK3f+wABxZHAUUrEA7IPSzFMbJkDZm+NDUVZK/ZR8qdP8QVDhRLTgyHC1EQRdBrvkYk4GU9junT3Id7q+ksPpDYP2H00lOZg1qu64DUVFoFS8F8MWhQHKjhQd14F1uGLnZ+yxPOubEh/My1tTUvDOnfGo2G7DYU+NAjnPHGZ8ciW5Kz+ZUeJNJSQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=VqJnmq5EO0ktz4LqavSeCLmKxfsEMlEEyN0KFh/uMzU=; b=VPVfbnWGDNBWdkB996mMJSQn4pZJIJAmyPc9Uy3z/YTGGjGE1TCvDDEVNYlxJ0RvEPNWhsJPZsR8gdjHai8xwZjIwU4lJhoEe+KNPHHdW/0+IQQg6O7uqSwIE/doNWoyMllLmLFOWO7B0FdruVW5ypUWcMzu6VDZvMYAOSl0fT4VTjN9K8GxGCKm+c+tabp6Jzc+zZ0Ahiw51NMiGAArfDBZYodZzMzcL4daPQFqdt+hDq2iz+tMFcjIqDjBmMsoY50AM4ZMd7qsxEq/as9gn6dOHbqt0xDkAk9t3Vg2DHrfxiUrgDdFHiJXI6mbU8VM0g72lJsZmcaIsdVPTQXEFw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=VqJnmq5EO0ktz4LqavSeCLmKxfsEMlEEyN0KFh/uMzU=; b=CFTqZEOBM1HHBl0XQCruQ6176giq4vDbJanX1k+C2A4Fltt7ZwEXeE3tDqFvoyhMcKNoPsEPPZbGpXOLpq+O/EeRiwdFRsGReTQyzyVVraNz3mECI1nfTRfHgLdN7vA9dky63mLHzicq9T50dNfuWVOjQ2vuR6qBZ3lw+V4D5bWc9TMAHX3J5UN1JPSeMKqs0jAHnG0iFFLy1upPA0tLO8Qx6iOkAcvKo+qJmQOwH1LpAvqAk3QM0FluZHflw4c1wVPMZSweEL5lDq3ANCBv1qQlAbVha90q+tfS9imoWjspH9X8dcSHlLRPBDOhNrjlhhZ0ounMNj73CB38lBraRA== Received: from SG2APC01FT116.eop-APC01.prod.protection.outlook.com (2a01:111:e400:7ebd::41) by SG2APC01HT075.eop-APC01.prod.protection.outlook.com (2a01:111:e400:7ebd::311) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.3477.21; Thu, 15 Oct 2020 16:45:35 +0000 Received: from SG2PR01MB2693.apcprd01.prod.exchangelabs.com (2a01:111:e400:7ebd::4f) by SG2APC01FT116.mail.protection.outlook.com (2a01:111:e400:7ebd::216) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.3477.21 via Frontend Transport; Thu, 15 Oct 2020 16:45:35 +0000 X-IncomingTopHeaderMarker: OriginalChecksum:AAB3AA4A42EDDA91D40F6FCA0183277DF542652A7E42C481E305D4310C9D0C32; UpperCasedChecksum:9EBB1B5274E779DC14EAD3DA657651308536CD5E8B51CF85A07799B1AF000D9B; SizeAsReceived:7392; Count:43 Received: from SG2PR01MB2693.apcprd01.prod.exchangelabs.com ([fe80::8c49:9a49:2ba9:dca2]) by SG2PR01MB2693.apcprd01.prod.exchangelabs.com ([fe80::8c49:9a49:2ba9:dca2%3]) with mapi id 15.20.3477.023; Thu, 15 Oct 2020 16:45:35 +0000 From: Nachiket Tarate To: ffmpeg-devel@ffmpeg.org Date: Thu, 15 Oct 2020 22:15:13 +0530 Message-ID: X-Mailer: git-send-email 2.17.1 X-TMN: [Hvy1PhuMXKlurdUiIUdJqCwls7OKt/eoSVReAAx7lMldjcsRrxhYKeDGVhSdMYIH] X-ClientProxiedBy: BM1PR01CA0146.INDPRD01.PROD.OUTLOOK.COM (2603:1096:b00:68::16) To SG2PR01MB2693.apcprd01.prod.exchangelabs.com (2603:1096:4:7f::14) X-Microsoft-Original-Message-ID: <20201015164513.15067-1-nachiket.tarate@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 Received: from localhost.localdomain (2401:4900:30c0:c467:93c:67d1:843b:b540) by BM1PR01CA0146.INDPRD01.PROD.OUTLOOK.COM (2603:1096:b00:68::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.3477.21 via Frontend Transport; Thu, 15 Oct 2020 16:45:33 +0000 X-MS-PublicTrafficType: Email X-IncomingHeaderCount: 43 X-EOPAttributedMessage: 0 X-MS-Office365-Filtering-Correlation-Id: 5243e9f7-3578-4526-d013-08d87129bc4f X-MS-TrafficTypeDiagnostic: SG2APC01HT075: X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: it9dfofBu6TT9r88wk7ukiivz33qmAMNawnSRVvO0YUnln7ZiIJEjbi09dAce3ycTrsghJYxQ2kvMkezNPN54KzHIrjNDQvr2+nVWXTTaFCskbuRSy7Y2upfDaUHZtQSdpg3dTfwUA98RQ38vw+FIrXm+lWqQV0mtTrd6CAnaSxUosCsVp6lEFQkhJavfveUfICUmLwmGB8FMvL8Y6deHvYb8+n5K1Z7YlDaZ2+x1Uhh50Adk1yuGeVEpoVTXiR8 X-MS-Exchange-AntiSpam-MessageData: hUthjj219oOZNF3VUX1q69J4xsBiHSE9EQq/izoozAGMQRo6bw4+GsvDYOlhvF/0LZMbJl7mKPH4VjfkKvMdi6k9ngO5tv2SFqrMj1KszKgmwbNVVew3JGbELvlX1lXSyuSW2Cs9xRKUgh8n0b1L8qvoPBdCub4bQpYIT4/w3zU+tVoe7QQM5eT51oweZ1BDqROmoNb1r71GSeR9PHS1ig== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 5243e9f7-3578-4526-d013-08d87129bc4f X-MS-Exchange-CrossTenant-OriginalArrivalTime: 15 Oct 2020 16:45:34.9164 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-AuthSource: SG2APC01FT116.eop-APC01.prod.protection.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: Internet X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SG2APC01HT075 Subject: [FFmpeg-devel] [PATCH] libavformat/hls: add support for SAMPLE-AES decryption in HLS demuxer X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" Apple HTTP Live Streaming Sample Encryption: https://developer.apple.com/library/ios/documentation/AudioVideo/Conceptual/HLS_Sample_Encryption Signed-off-by: Nachiket Tarate --- libavformat/Makefile | 2 +- libavformat/hls.c | 93 ++++++- libavformat/hls_sample_aes.c | 497 +++++++++++++++++++++++++++++++++++ libavformat/hls_sample_aes.h | 64 +++++ libavformat/mpegts.c | 15 ++ 5 files changed, 657 insertions(+), 14 deletions(-) create mode 100644 libavformat/hls_sample_aes.c create mode 100644 libavformat/hls_sample_aes.h diff --git a/libavformat/Makefile b/libavformat/Makefile index a5e8bddb87..0ccec2d281 100644 --- a/libavformat/Makefile +++ b/libavformat/Makefile @@ -235,7 +235,7 @@ OBJS-$(CONFIG_HCOM_DEMUXER) += hcom.o pcm.o OBJS-$(CONFIG_HDS_MUXER) += hdsenc.o OBJS-$(CONFIG_HEVC_DEMUXER) += hevcdec.o rawdec.o OBJS-$(CONFIG_HEVC_MUXER) += rawenc.o -OBJS-$(CONFIG_HLS_DEMUXER) += hls.o +OBJS-$(CONFIG_HLS_DEMUXER) += hls.o hls_sample_aes.o OBJS-$(CONFIG_HLS_MUXER) += hlsenc.o hlsplaylist.o OBJS-$(CONFIG_HNM_DEMUXER) += hnm.o OBJS-$(CONFIG_ICO_DEMUXER) += icodec.o diff --git a/libavformat/hls.c b/libavformat/hls.c index 72e28ab94f..63683e4742 100644 --- a/libavformat/hls.c +++ b/libavformat/hls.c @@ -2,6 +2,7 @@ * Apple HTTP Live Streaming demuxer * Copyright (c) 2010 Martin Storsjo * Copyright (c) 2013 Anssi Hannula + * Copyright (c) 2020 Nachiket Tarate * * This file is part of FFmpeg. * @@ -39,6 +40,8 @@ #include "avio_internal.h" #include "id3v2.h" +#include "hls_sample_aes.h" + #define INITIAL_BUFFER_SIZE 32768 #define MAX_FIELD_LEN 64 @@ -145,6 +148,8 @@ struct playlist { int id3_changed; /* ID3 tag data has changed at some point */ ID3v2ExtraMeta *id3_deferred_extra; /* stored here until subdemuxer is opened */ + HLSAudioSetupInfo audio_setup_info; + int64_t seek_timestamp; int seek_flags; int seek_stream_index; /* into subdemuxer stream array */ @@ -1015,10 +1020,11 @@ static int read_from_url(struct playlist *pls, struct segment *seg, /* Parse the raw ID3 data and pass contents to caller */ static void parse_id3(AVFormatContext *s, AVIOContext *pb, - AVDictionary **metadata, int64_t *dts, + AVDictionary **metadata, int64_t *dts, HLSAudioSetupInfo *audio_setup_info, ID3v2ExtraMetaAPIC **apic, ID3v2ExtraMeta **extra_meta) { static const char id3_priv_owner_ts[] = "com.apple.streaming.transportStreamTimestamp"; + static const char id3_priv_owner_audio_setup[] = "com.apple.streaming.audioDescription"; ID3v2ExtraMeta *meta; ff_id3v2_read_dict(pb, metadata, ID3v2_DEFAULT_MAGIC, extra_meta); @@ -1034,6 +1040,9 @@ static void parse_id3(AVFormatContext *s, AVIOContext *pb, else av_log(s, AV_LOG_ERROR, "Invalid HLS ID3 audio timestamp %"PRId64"\n", ts); } + else if (priv->datasize >= 8 && !strcmp(priv->owner, id3_priv_owner_audio_setup)) { + ff_hls_read_audio_setup_info(audio_setup_info, priv->data, priv->datasize); + } } else if (!strcmp(meta->tag, "APIC") && apic) *apic = &meta->data.apic; } @@ -1076,7 +1085,7 @@ static void handle_id3(AVIOContext *pb, struct playlist *pls) ID3v2ExtraMeta *extra_meta = NULL; int64_t timestamp = AV_NOPTS_VALUE; - parse_id3(pls->ctx, pb, &metadata, ×tamp, &apic, &extra_meta); + parse_id3(pls->ctx, pb, &metadata, ×tamp, &pls->audio_setup_info, &apic, &extra_meta); if (timestamp != AV_NOPTS_VALUE) { pls->id3_mpegts_timestamp = timestamp; @@ -1230,10 +1239,7 @@ static int open_input(HLSContext *c, struct playlist *pls, struct segment *seg, av_log(pls->parent, AV_LOG_VERBOSE, "HLS request for url '%s', offset %"PRId64", playlist %d\n", seg->url, seg->url_offset, pls->index); - if (seg->key_type == KEY_NONE) { - ret = open_url(pls->parent, in, seg->url, &c->avio_opts, opts, &is_http); - } else if (seg->key_type == KEY_AES_128) { - char iv[33], key[33], url[MAX_URL_SIZE]; + if (seg->key_type == KEY_AES_128 || seg->key_type == KEY_SAMPLE_AES) { if (strcmp(seg->key, pls->key_url)) { AVIOContext *pb = NULL; if (open_url(pls->parent, &pb, seg->key, &c->avio_opts, opts, NULL) == 0) { @@ -1249,6 +1255,10 @@ static int open_input(HLSContext *c, struct playlist *pls, struct segment *seg, } av_strlcpy(pls->key_url, seg->key, sizeof(pls->key_url)); } + } + + if (seg->key_type == KEY_AES_128) { + char iv[33], key[33], url[MAX_URL_SIZE]; ff_data_to_hex(iv, seg->iv, sizeof(seg->iv), 0); ff_data_to_hex(key, pls->key, sizeof(pls->key), 0); iv[32] = key[32] = '\0'; @@ -1265,14 +1275,9 @@ static int open_input(HLSContext *c, struct playlist *pls, struct segment *seg, goto cleanup; } ret = 0; - } else if (seg->key_type == KEY_SAMPLE_AES) { - av_log(pls->parent, AV_LOG_ERROR, - "SAMPLE-AES encryption is not supported yet\n"); - ret = AVERROR_PATCHWELCOME; + } else { + ret = open_url(pls->parent, in, seg->url, &c->avio_opts, opts, &is_http); } - else - ret = AVERROR(ENOSYS); - /* Seek to the requested position. If this was a HTTP request, the offset * should already be where want it to, but this allows e.g. local testing * without a HTTP server. @@ -1940,6 +1945,7 @@ static int hls_read_header(AVFormatContext *s) struct playlist *pls = c->playlists[i]; char *url; ff_const59 AVInputFormat *in_fmt = NULL; + struct segment *seg = NULL; if (!(pls->ctx = avformat_alloc_context())) { ret = AVERROR(ENOMEM); @@ -1972,8 +1978,52 @@ static int hls_read_header(AVFormatContext *s) pls->ctx = NULL; goto fail; } + ffio_init_context(&pls->pb, pls->read_buffer, INITIAL_BUFFER_SIZE, 0, pls, read_data, NULL, NULL); + + /* + * If encryption scheme is SAMPLE-AES, try to read ID3 tags of + * external audio track that contains audio setup information + */ + seg = current_segment(pls); + if (seg && seg->key_type == KEY_SAMPLE_AES && pls->n_renditions > 0 && + pls->renditions[0]->type == AVMEDIA_TYPE_AUDIO) { + + uint8_t *buf = av_malloc(HLS_MAX_ID3_TAGS_DATA_LEN); + if (!buf) { + ret = AVERROR(ENOMEM); + avformat_free_context(pls->ctx); + pls->ctx = NULL; + goto fail; + } + + if ((ret = avio_read(&pls->pb, buf, HLS_MAX_ID3_TAGS_DATA_LEN)) < 0) { + /* Fail if error was not end of file */ + if (ret != AVERROR_EOF) { + av_free(buf); + avformat_free_context(pls->ctx); + pls->ctx = NULL; + goto fail; + } + ret = 0; /* error was end of file, nothing read */ + } + + av_free(buf); + } + + /* + * If encryption scheme is SAMPLE-AES and audio setup information is present in external audio track, + * use that information to find the media format, otherwise probe input data + */ + if (seg->key_type == KEY_SAMPLE_AES && pls->is_id3_timestamped == 1 && + pls->audio_setup_info.codec_id != AV_CODEC_ID_NONE) { + void *i = 0; + while ((in_fmt = (ff_const59 AVInputFormat *)av_demuxer_iterate(&i))) + if (in_fmt->raw_codec_id == pls->audio_setup_info.codec_id) { + break; + } + } else { pls->ctx->probesize = s->probesize > 0 ? s->probesize : 1024 * 4; pls->ctx->max_analyze_duration = s->max_analyze_duration > 0 ? s->max_analyze_duration : 4 * AV_TIME_BASE; pls->ctx->interrupt_callback = s->interrupt_callback; @@ -1990,6 +2040,8 @@ static int hls_read_header(AVFormatContext *s) pls->ctx = NULL; goto fail; } + } + pls->ctx->pb = &pls->pb; pls->ctx->io_open = nested_io_open; pls->ctx->flags |= s->flags & ~AVFMT_FLAG_CUSTOM_IO; @@ -2018,9 +2070,14 @@ static int hls_read_header(AVFormatContext *s) * on us if they want to. */ if (pls->is_id3_timestamped || (pls->n_renditions > 0 && pls->renditions[0]->type == AVMEDIA_TYPE_AUDIO)) { + if (seg && seg->key_type == KEY_SAMPLE_AES && pls->audio_setup_info.setup_data_length > 0 && + pls->ctx->nb_streams == 1) { + ff_hls_parse_audio_setup_info(pls->ctx->streams[0], &pls->audio_setup_info); + } else { ret = avformat_find_stream_info(pls->ctx, NULL); if (ret < 0) goto fail; + } } pls->has_noheader_flag = !!(pls->ctx->ctx_flags & AVFMTCTX_NOHEADER); @@ -2142,6 +2199,7 @@ static int hls_read_packet(AVFormatContext *s, AVPacket *pkt) for (i = 0; i < c->n_playlists; i++) { struct playlist *pls = c->playlists[i]; + struct segment *seg = NULL; /* Make sure we've got one buffered packet from each open playlist * stream */ if (pls->needed && !pls->pkt.data) { @@ -2166,6 +2224,15 @@ static int hls_read_packet(AVFormatContext *s, AVPacket *pkt) get_timebase(pls), AV_TIME_BASE_Q); } + seg = current_segment(pls); + if (seg && seg->key_type == KEY_SAMPLE_AES) { + HLSCryptoContext crypto_ctx; + enum AVCodecID codec_id = pls->ctx->streams[pls->pkt.stream_index]->codecpar->codec_id; + memcpy(crypto_ctx.iv, seg->iv, sizeof(seg->iv)); + memcpy(crypto_ctx.key, pls->key, sizeof(pls->key)); + ff_hls_decrypt_frame(codec_id, &crypto_ctx, &pls->pkt); + } + if (pls->seek_timestamp == AV_NOPTS_VALUE) break; diff --git a/libavformat/hls_sample_aes.c b/libavformat/hls_sample_aes.c new file mode 100644 index 0000000000..41d501fde3 --- /dev/null +++ b/libavformat/hls_sample_aes.c @@ -0,0 +1,497 @@ +/* + * Apple HTTP Live Streaming Sample Decryption + * + * Copyright (c) 2020 Nachiket Tarate + * + * 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 + * Apple HTTP Live Streaming Sample Decryption + * https://developer.apple.com/library/ios/documentation/AudioVideo/Conceptual/HLS_Sample_Encryption + */ + +#include "hls_sample_aes.h" + +#include "libavcodec/adts_parser.h" +#include "libavcodec/ac3_parser_internal.h" +#include "libavutil/aes.h" + + +typedef struct NALUnit { + uint8_t *data; + int type; + int length; +} NALUnit; + +typedef struct AudioFrame { + uint8_t *data; + int length; + int header_length; +} AudioFrame; + +typedef struct AVParserContext { + const uint8_t *buf_in; + const uint8_t *buf_end; + uint8_t *buf_out; + int next_start_code_length; +} AVParserContext; + +static const int eac3_sample_rate_tab[] = { 48000, 44100, 32000, 0 }; + +void ff_hls_read_audio_setup_info(HLSAudioSetupInfo *info, const uint8_t *buf, size_t size) +{ + info->codec_tag = AV_RL32(buf); + + if (!strncmp((const char*)&info->codec_tag, "zaac", 4)) + info->codec_id = AV_CODEC_ID_AAC; + else if (!strncmp((const char*)&info->codec_tag, "zac3", 4)) + info->codec_id = AV_CODEC_ID_AC3; + else if (!strncmp((const char*)&info->codec_tag, "zec3", 4)) + info->codec_id = AV_CODEC_ID_EAC3; + else + info->codec_id = AV_CODEC_ID_NONE; + + buf += 4; + info->priming = AV_RL16(buf); + buf += 2; + info->version = *buf++; + info->setup_data_length = *buf++; + + memcpy(info->setup_data, buf, info->setup_data_length); +} + +/* + * Parse 'dec3' EC3SpecificBox + */ +static int parse_dec3(AC3HeaderInfo **phdr, const uint8_t *buf, size_t size) +{ + GetBitContext gb; + AC3HeaderInfo *hdr; + int err; + + int data_rate, fscod, acmod, lfeon; + + if (!*phdr) + *phdr = av_mallocz(sizeof(AC3HeaderInfo)); + if (!*phdr) + return AVERROR(ENOMEM); + hdr = *phdr; + + err = init_get_bits8(&gb, buf, size); + if (err < 0) + return AVERROR_INVALIDDATA; + + data_rate = get_bits(&gb, 13); + skip_bits(&gb, 3); + fscod = get_bits(&gb, 2); + skip_bits(&gb, 10); + acmod = get_bits(&gb, 3); + lfeon = get_bits(&gb, 1); + + hdr->sample_rate = eac3_sample_rate_tab[fscod]; + + hdr->channel_layout = avpriv_ac3_channel_layout_tab[acmod]; + if (lfeon) + hdr->channel_layout |= AV_CH_LOW_FREQUENCY; + + hdr->channels = av_get_channel_layout_nb_channels(hdr->channel_layout); + + hdr->bit_rate = data_rate*1000; + + return 0; +} + +int ff_hls_parse_audio_setup_info(AVStream *st, HLSAudioSetupInfo *info) +{ + int ret = 0; + + AC3HeaderInfo *ac3hdr = NULL; + + st->codecpar->codec_tag = info->codec_tag; + + if (st->codecpar->codec_id == AV_CODEC_ID_AAC) + return 0; + + st->codecpar->extradata = av_mallocz(info->setup_data_length + AV_INPUT_BUFFER_PADDING_SIZE); + + if (!st->codecpar->extradata) + return AVERROR(ENOMEM); + + st->codecpar->extradata_size = info->setup_data_length; + + if (st->codecpar->codec_id == AV_CODEC_ID_AC3) + ret = avpriv_ac3_parse_header(&ac3hdr, info->setup_data, info->setup_data_length); + else if (st->codecpar->codec_id == AV_CODEC_ID_EAC3) + ret = parse_dec3(&ac3hdr, info->setup_data, info->setup_data_length); + else + return -1; + + if (ret < 0) { + if (ret != AVERROR(ENOMEM)) { + av_free(ac3hdr); + } + return ret; + } + + st->codecpar->sample_rate = ac3hdr->sample_rate; + st->codecpar->channels = ac3hdr->channels; + st->codecpar->channel_layout = ac3hdr->channel_layout; + st->codecpar->bit_rate = ac3hdr->bit_rate; + + av_free(ac3hdr); + + return 0; +} + +/* + * Remove start code emulation prevention 0x03 bytes + */ +static void remove_scep_3_bytes (NALUnit *nalu) +{ + int i = 0; + int j = 0; + + uint8_t *data = nalu->data; + + while (i < nalu->length) { + if (nalu->length - i > 3 && data[i] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x03 && + (data[i+3] == 0x00 || data[i+3] == 0x01 || data[i+3] == 0x02 || data[i+3] == 0x03)) { + data[j] = 0x00; + data[j+1] = 0x00; + data[j+2] = data[i+3]; + i += 4; + j += 3; + } else { + data[j++] = data[i++]; + } + } + + nalu->length = j; +} + +static int is_start_code (const uint8_t *buf, int zeros_in_start_code) +{ + int i; + + for (i = 0; i < zeros_in_start_code; i++) { + if(*(buf++) != 0x00) { + return 0; + } + } + + if(*buf != 0x01) + return 0; + + return 1; +} + +static int get_next_nal_unit (AVParserContext *ctx, NALUnit *nalu) +{ + int i; + int len = 0; + int nalu_start_offset = 0; + + uint8_t *buf_out = ctx->buf_out; + + if (ctx->next_start_code_length != 0) { + for (i = 0; i < ctx->next_start_code_length - 1; i++) { + *buf_out++ = 0; + len++; + } + *buf_out++ = 1; + len++; + ctx->next_start_code_length = 0; + } else { + while (ctx->buf_in < ctx->buf_end) { + len++; + if ((*buf_out++ = *ctx->buf_in++) != 0) + break; + } + } + + if (ctx->buf_in >= ctx->buf_end) { + if (len == 0) + return 0; + else + return -1; + } + + /* No start code at the beginning of the NAL unit */ + if(*(ctx->buf_in - 1) != 1 || len < 3) { + return -1; + } + + nalu_start_offset = len; + + while (ctx->next_start_code_length == 0) { + if (ctx->buf_in >= ctx->buf_end) { + nalu->data = ctx->buf_out + nalu_start_offset; + nalu->length = len - nalu_start_offset; + nalu->type = *nalu->data & 0x1F; + ctx->buf_out += nalu_start_offset; + return 0; + } + *buf_out++ = *ctx->buf_in++; + len++; + if (is_start_code(ctx->buf_in - 4, 3)) + ctx->next_start_code_length = 4; + else if (is_start_code(ctx->buf_in - 3, 2)) + ctx->next_start_code_length = 3; + else + ctx->next_start_code_length = 0; + } + + len -= ctx->next_start_code_length; + + nalu->data = ctx->buf_out + nalu_start_offset; + nalu->length = len - nalu_start_offset; + nalu->type = *nalu->data & 0x1F; + ctx->buf_out += nalu_start_offset; + return 0; +} + +static int decrypt_nal_unit (HLSCryptoContext *crypto_ctx, NALUnit *nalu) +{ + int ret = 0; + int rem_bytes; + uint8_t *data; + uint8_t iv[16]; + uint8_t decrypted_block[16]; + + struct AVAES *aes_ctx = av_aes_alloc(); + if (!aes_ctx) { + return AVERROR(ENOMEM); + } + + ret = av_aes_init(aes_ctx, crypto_ctx->key, 16 * 8, 1); + if (ret < 0) { + return ret; + } + + /* Remove start code emulation prevention 0x03 bytes */ + remove_scep_3_bytes(nalu); + + data = nalu->data + 32; + rem_bytes = nalu->length - 32; + + memcpy(iv, crypto_ctx->iv, 16); + + while (rem_bytes > 0) { + if (rem_bytes > 16) { + av_aes_crypt(aes_ctx, decrypted_block, data, 1, iv, 1); + memcpy(iv, data, 16); + memcpy(data, decrypted_block, 16); + data += 16; + rem_bytes -= 16; + } + data += 144; + rem_bytes -= 144; + } + + av_free(aes_ctx); + + return 0; +} + +static int decrypt_video_frame (HLSCryptoContext *crypto_ctx, AVPacket *pkt) +{ + int ret = 0; + AVParserContext ctx; + NALUnit nalu; + + memset(&ctx, 0, sizeof(ctx)); + ctx.buf_in = pkt->data; + ctx.buf_out = pkt->data; + ctx.buf_end = pkt->data + pkt->size; + + while (ctx.buf_in < ctx.buf_end) { + memset(&nalu, 0, sizeof(nalu)); + ret = get_next_nal_unit(&ctx, &nalu); + if (ret < 0) { + return ret; + } + if ((nalu.type == 0x01 || nalu.type == 0x05) && nalu.length > 48) { + ret = decrypt_nal_unit(crypto_ctx, &nalu); + if (ret < 0) { + return ret; + } + } + ctx.buf_out += nalu.length; + } + + av_shrink_packet(pkt, ctx.buf_out - pkt->data); + + return 0; +} + +static int get_next_adts_frame (AVParserContext *ctx, AudioFrame *frame) +{ + int ret = 0; + + AACADTSHeaderInfo *adts_hdr = NULL; + + /* Find next sync word 0xFFF */ + while (ctx->buf_in < ctx->buf_end - 1) { + if (*ctx->buf_in == 0xFF && *(ctx->buf_in + 1) & 0xF0 == 0xF0) + break; + ctx->buf_in++; + } + + if (ctx->buf_in >= ctx->buf_end - 1) { + return -1; + } + + frame->data = (uint8_t*)ctx->buf_in; + + ret = avpriv_adts_header_parse (&adts_hdr, frame->data, ctx->buf_end - frame->data); + if (ret < 0) { + return ret; + } + + frame->header_length = adts_hdr->crc_absent ? AV_AAC_ADTS_HEADER_SIZE : AV_AAC_ADTS_HEADER_SIZE + 2; + frame->length = adts_hdr->frame_length; + + av_free(adts_hdr); + + return 0; +} + +static int get_next_ac3_eac3_sync_frame (AVParserContext *ctx, AudioFrame *frame) +{ + int ret = 0; + + AC3HeaderInfo *hdr = NULL; + + /* Find next sync word 0x0B77 */ + while (ctx->buf_in < ctx->buf_end - 1) { + if (*ctx->buf_in == 0x0B && *(ctx->buf_in + 1) == 0x77) + break; + ctx->buf_in++; + } + + if (ctx->buf_in >= ctx->buf_end - 1) { + return -1; + } + + frame->data = (uint8_t*)ctx->buf_in; + frame->header_length = 0; + + ret = avpriv_ac3_parse_header(&hdr, frame->data, ctx->buf_end - frame->data); + if (ret < 0) { + if (ret != AVERROR(ENOMEM)) { + av_free(hdr); + } + return ret; + } + + frame->length = hdr->frame_size; + + av_free(hdr); + + return 0; +} + +static int get_next_sync_frame (enum AVCodecID codec_id, AVParserContext *ctx, AudioFrame *frame) +{ + if (codec_id == AV_CODEC_ID_AAC) + return get_next_adts_frame(ctx, frame); + else if (codec_id == AV_CODEC_ID_AC3 || codec_id == AV_CODEC_ID_EAC3) + return get_next_ac3_eac3_sync_frame(ctx, frame); + else + return -1; +} + + +static int decrypt_sync_frame (enum AVCodecID codec_id, HLSCryptoContext *crypto_ctx, AudioFrame *frame) +{ + int ret = 0; + uint8_t *data; + uint8_t *decrypted_data; + int num_of_encrypted_blocks; + + struct AVAES *aes_ctx = av_aes_alloc(); + if (!aes_ctx) { + return AVERROR(ENOMEM); + } + + ret = av_aes_init(aes_ctx, crypto_ctx->key, 16 * 8, 1); + if (ret < 0) { + return ret; + } + + data = frame->data + frame->header_length + 16; + + num_of_encrypted_blocks = (frame->length - frame->header_length - 16)/16; + + decrypted_data = (uint8_t *)av_mallocz(num_of_encrypted_blocks*16); + if (!decrypted_data) { + return AVERROR(ENOMEM); + } + + av_aes_crypt(aes_ctx, decrypted_data, data, num_of_encrypted_blocks, crypto_ctx->iv, 1); + + if (codec_id == AV_CODEC_ID_EAC3) + memcpy(crypto_ctx->iv, data + (num_of_encrypted_blocks - 1)*16, 16); + + memcpy(data, decrypted_data, num_of_encrypted_blocks*16); + + av_free(decrypted_data); + av_free(aes_ctx); + + return 0; +} + +static int decrypt_audio_frame (enum AVCodecID codec_id, HLSCryptoContext *crypto_ctx, AVPacket *pkt) +{ + int ret = 0; + AVParserContext ctx; + AudioFrame frame; + + memset(&ctx, 0, sizeof(ctx)); + ctx.buf_in = pkt->data; + ctx.buf_end = pkt->data + pkt->size; + + while (ctx.buf_in < ctx.buf_end) { + memset(&frame, 0, sizeof(frame)); + ret = get_next_sync_frame(codec_id, &ctx, &frame); + if (ret < 0) { + return ret; + } + if (frame.length - frame.header_length > 31) { + ret = decrypt_sync_frame(codec_id, crypto_ctx, &frame); + if (ret < 0) { + return ret; + } + } + ctx.buf_in += frame.length; + } + + return 0; +} + + +int ff_hls_decrypt_frame (enum AVCodecID codec_id, HLSCryptoContext *crypto_ctx, AVPacket *pkt) +{ + if (codec_id == AV_CODEC_ID_H264) + return decrypt_video_frame(crypto_ctx, pkt); + else if (codec_id == AV_CODEC_ID_AAC || codec_id == AV_CODEC_ID_AC3 || codec_id == AV_CODEC_ID_EAC3) + return decrypt_audio_frame(codec_id, crypto_ctx, pkt); + + return -1; +} diff --git a/libavformat/hls_sample_aes.h b/libavformat/hls_sample_aes.h new file mode 100644 index 0000000000..7fb1d57a81 --- /dev/null +++ b/libavformat/hls_sample_aes.h @@ -0,0 +1,64 @@ +/* + * Apple HTTP Live Streaming Sample Decryption + * + * Copyright (c) 2020 Nachiket Tarate + * + * 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 + * Apple HTTP Live Streaming Sample Decryption + * https://developer.apple.com/library/ios/documentation/AudioVideo/Conceptual/HLS_Sample_Encryption + */ + +#ifndef AVFORMAT_HLS_SAMPLE_DECRYPT_H +#define AVFORMAT_HLS_SAMPLE_DECRYPT_H + +#include + +#include "avformat.h" + +#include "libavcodec/avcodec.h" + +#define HLS_MAX_ID3_TAGS_DATA_LEN 138 +#define HLS_MAX_AUDIO_SETUP_DATA_LEN 10 + + +typedef struct HLSCryptoContext { + uint8_t key[16]; + uint8_t iv[16]; +} HLSCryptoContext; + +typedef struct HLSAudioSetupInfo { + enum AVCodecID codec_id; + uint32_t codec_tag; + uint16_t priming; + uint8_t version; + uint8_t setup_data_length; + uint8_t setup_data[HLS_MAX_AUDIO_SETUP_DATA_LEN]; +} HLSAudioSetupInfo; + + +void ff_hls_read_audio_setup_info(HLSAudioSetupInfo *info, const uint8_t *buf, size_t size); + +int ff_hls_parse_audio_setup_info(AVStream *st, HLSAudioSetupInfo *info); + +int ff_hls_decrypt_frame (enum AVCodecID codec_id, HLSCryptoContext *crypto_ctx, AVPacket *pkt); + +#endif /* AVFORMAT_HLS_SAMPLE_DECRYPT_H */ + diff --git a/libavformat/mpegts.c b/libavformat/mpegts.c index 432b1c3ea2..cf274ca5ec 100644 --- a/libavformat/mpegts.c +++ b/libavformat/mpegts.c @@ -838,6 +838,16 @@ static const StreamType MISC_types[] = { { 0 }, }; +/* HLS Sample Encryption Types */ +static const StreamType HLS_SAMPLE_ENC_types[] = { + { 0xdb, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H264}, + { 0xcf, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC }, + { 0xc1, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, + { 0xc2, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3}, + { 0 }, +}; + + static const StreamType REGD_types[] = { { MKTAG('d', 'r', 'a', 'c'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC }, { MKTAG('A', 'C', '-', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, @@ -947,6 +957,8 @@ static int mpegts_set_stream_info(AVStream *st, PESContext *pes, } if (st->codecpar->codec_id == AV_CODEC_ID_NONE) mpegts_find_stream_type(st, pes->stream_type, MISC_types); + if (st->codecpar->codec_id == AV_CODEC_ID_NONE) + mpegts_find_stream_type(st, pes->stream_type, HLS_SAMPLE_ENC_types); if (st->codecpar->codec_id == AV_CODEC_ID_NONE) { st->codecpar->codec_id = old_codec_id; st->codecpar->codec_type = old_codec_type; @@ -1987,6 +1999,9 @@ int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type case 0x05: /* registration descriptor */ st->codecpar->codec_tag = bytestream_get_le32(pp); av_log(fc, AV_LOG_TRACE, "reg_desc=%.4s\n", (char *)&st->codecpar->codec_tag); + if (st->codecpar->codec_tag == MKTAG('a', 'p', 'a', 'd')) { + st->codecpar->codec_tag = bytestream_get_le32(pp); + } if (st->codecpar->codec_id == AV_CODEC_ID_NONE || st->request_probe > 0) { mpegts_find_stream_type(st, st->codecpar->codec_tag, REGD_types); if (st->codecpar->codec_tag == MKTAG('B', 'S', 'S', 'D'))