| 4469e8eb |
/*
* MOV CENC (Common Encryption) writer
* Copyright (c) 2015 Eran Kornblau <erankor at gmail dot com>
*
* 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 "movenccenc.h"
#include "libavutil/intreadwrite.h"
#include "avio_internal.h"
#include "movenc.h"
#include "avc.h"
static int auxiliary_info_alloc_size(MOVMuxCencContext* ctx, int size)
{
size_t new_alloc_size;
if (ctx->auxiliary_info_size + size > ctx->auxiliary_info_alloc_size) {
new_alloc_size = FFMAX(ctx->auxiliary_info_size + size, ctx->auxiliary_info_alloc_size * 2);
if (av_reallocp(&ctx->auxiliary_info, new_alloc_size)) {
return AVERROR(ENOMEM);
}
ctx->auxiliary_info_alloc_size = new_alloc_size;
}
return 0;
}
static int auxiliary_info_write(MOVMuxCencContext* ctx,
const uint8_t *buf_in, int size)
{
int ret;
ret = auxiliary_info_alloc_size(ctx, size);
if (ret) {
return ret;
}
memcpy(ctx->auxiliary_info + ctx->auxiliary_info_size, buf_in, size);
ctx->auxiliary_info_size += size;
return 0;
}
static int auxiliary_info_add_subsample(MOVMuxCencContext* ctx,
uint16_t clear_bytes, uint32_t encrypted_bytes)
{
uint8_t* p;
int ret;
if (!ctx->use_subsamples) {
return 0;
}
ret = auxiliary_info_alloc_size(ctx, 6);
if (ret) {
return ret;
}
p = ctx->auxiliary_info + ctx->auxiliary_info_size;
AV_WB16(p, clear_bytes);
p += sizeof(uint16_t);
AV_WB32(p, encrypted_bytes);
ctx->auxiliary_info_size += 6;
ctx->subsample_count++;
return 0;
}
/**
* Encrypt the input buffer and write using avio_write
*/
static void mov_cenc_write_encrypted(MOVMuxCencContext* ctx, AVIOContext *pb,
const uint8_t *buf_in, int size)
{
uint8_t chunk[4096];
const uint8_t* cur_pos = buf_in;
int size_left = size;
int cur_size;
while (size_left > 0) {
cur_size = FFMIN(size_left, sizeof(chunk));
av_aes_ctr_crypt(ctx->aes_ctr, chunk, cur_pos, cur_size);
avio_write(pb, chunk, cur_size);
cur_pos += cur_size;
size_left -= cur_size;
}
}
/**
* Start writing a packet
*/
static int mov_cenc_start_packet(MOVMuxCencContext* ctx)
{
int ret;
/* write the iv */
ret = auxiliary_info_write(ctx, av_aes_ctr_get_iv(ctx->aes_ctr), AES_CTR_IV_SIZE);
if (ret) {
return ret;
}
if (!ctx->use_subsamples) {
return 0;
}
/* write a zero subsample count */
ctx->auxiliary_info_subsample_start = ctx->auxiliary_info_size;
ctx->subsample_count = 0;
ret = auxiliary_info_write(ctx, (uint8_t*)&ctx->subsample_count, sizeof(ctx->subsample_count));
if (ret) {
return ret;
}
return 0;
}
/**
* Finalize a packet
*/
static int mov_cenc_end_packet(MOVMuxCencContext* ctx)
{
size_t new_alloc_size;
av_aes_ctr_increment_iv(ctx->aes_ctr);
if (!ctx->use_subsamples) {
ctx->auxiliary_info_entries++;
return 0;
}
/* add the auxiliary info entry size*/
if (ctx->auxiliary_info_entries >= ctx->auxiliary_info_sizes_alloc_size) {
new_alloc_size = ctx->auxiliary_info_entries * 2 + 1;
if (av_reallocp(&ctx->auxiliary_info_sizes, new_alloc_size)) {
return AVERROR(ENOMEM);
}
ctx->auxiliary_info_sizes_alloc_size = new_alloc_size;
}
ctx->auxiliary_info_sizes[ctx->auxiliary_info_entries] =
AES_CTR_IV_SIZE + ctx->auxiliary_info_size - ctx->auxiliary_info_subsample_start;
ctx->auxiliary_info_entries++;
/* update the subsample count*/
AV_WB16(ctx->auxiliary_info + ctx->auxiliary_info_subsample_start, ctx->subsample_count);
return 0;
}
int ff_mov_cenc_write_packet(MOVMuxCencContext* ctx, AVIOContext *pb,
const uint8_t *buf_in, int size)
{
int ret;
ret = mov_cenc_start_packet(ctx);
if (ret) {
return ret;
}
ret = auxiliary_info_add_subsample(ctx, 0, size);
if (ret) {
return ret;
}
mov_cenc_write_encrypted(ctx, pb, buf_in, size);
ret = mov_cenc_end_packet(ctx);
if (ret) {
return ret;
}
return 0;
}
int ff_mov_cenc_avc_parse_nal_units(MOVMuxCencContext* ctx, AVIOContext *pb,
const uint8_t *buf_in, int size)
{
const uint8_t *p = buf_in;
const uint8_t *end = p + size;
const uint8_t *nal_start, *nal_end;
int ret;
ret = mov_cenc_start_packet(ctx);
if (ret) {
return ret;
}
size = 0;
nal_start = ff_avc_find_startcode(p, end);
for (;;) {
while (nal_start < end && !*(nal_start++));
if (nal_start == end)
break;
nal_end = ff_avc_find_startcode(nal_start, end);
avio_wb32(pb, nal_end - nal_start);
avio_w8(pb, *nal_start);
mov_cenc_write_encrypted(ctx, pb, nal_start + 1, nal_end - nal_start - 1);
auxiliary_info_add_subsample(ctx, 5, nal_end - nal_start - 1);
size += 4 + nal_end - nal_start;
nal_start = nal_end;
}
ret = mov_cenc_end_packet(ctx);
if (ret) {
return ret;
}
return size;
}
int ff_mov_cenc_avc_write_nal_units(AVFormatContext *s, MOVMuxCencContext* ctx,
int nal_length_size, AVIOContext *pb, const uint8_t *buf_in, int size)
{
int nalsize;
int ret;
int j;
ret = mov_cenc_start_packet(ctx);
if (ret) {
return ret;
}
while (size > 0) {
/* parse the nal size */
if (size < nal_length_size + 1) {
av_log(s, AV_LOG_ERROR, "CENC-AVC: remaining size %d smaller than nal length+type %d\n",
size, nal_length_size + 1);
return -1;
}
avio_write(pb, buf_in, nal_length_size + 1);
nalsize = 0;
for (j = 0; j < nal_length_size; j++) {
nalsize = (nalsize << 8) | *buf_in++;
}
size -= nal_length_size;
/* encrypt the nal body */
if (nalsize <= 0 || nalsize > size) {
av_log(s, AV_LOG_ERROR, "CENC-AVC: nal size %d remaining %d\n", nalsize, size);
return -1;
}
mov_cenc_write_encrypted(ctx, pb, buf_in + 1, nalsize - 1);
buf_in += nalsize;
size -= nalsize;
auxiliary_info_add_subsample(ctx, nal_length_size + 1, nalsize - 1);
}
ret = mov_cenc_end_packet(ctx);
if (ret) {
return ret;
}
return 0;
}
/* TODO: reuse this function from movenc.c */
static int64_t update_size(AVIOContext *pb, int64_t pos)
{
int64_t curpos = avio_tell(pb);
avio_seek(pb, pos, SEEK_SET);
avio_wb32(pb, curpos - pos); /* rewrite size */
avio_seek(pb, curpos, SEEK_SET);
return curpos - pos;
}
static int mov_cenc_write_senc_tag(MOVMuxCencContext* ctx, AVIOContext *pb,
int64_t* auxiliary_info_offset)
{
int64_t pos = avio_tell(pb);
avio_wb32(pb, 0); /* size */
ffio_wfourcc(pb, "senc");
avio_wb32(pb, ctx->use_subsamples ? 0x02 : 0); /* version & flags */
avio_wb32(pb, ctx->auxiliary_info_entries); /* entry count */
*auxiliary_info_offset = avio_tell(pb);
avio_write(pb, ctx->auxiliary_info, ctx->auxiliary_info_size);
return update_size(pb, pos);
}
static int mov_cenc_write_saio_tag(AVIOContext *pb, int64_t auxiliary_info_offset)
{
int64_t pos = avio_tell(pb);
uint8_t version;
avio_wb32(pb, 0); /* size */
ffio_wfourcc(pb, "saio");
version = auxiliary_info_offset > 0xffffffff ? 1 : 0;
avio_w8(pb, version);
avio_wb24(pb, 0); /* flags */
avio_wb32(pb, 1); /* entry count */
if (version) {
avio_wb64(pb, auxiliary_info_offset);
} else {
avio_wb32(pb, auxiliary_info_offset);
}
return update_size(pb, pos);
}
static int mov_cenc_write_saiz_tag(MOVMuxCencContext* ctx, AVIOContext *pb)
{
int64_t pos = avio_tell(pb);
avio_wb32(pb, 0); /* size */
ffio_wfourcc(pb, "saiz");
avio_wb32(pb, 0); /* version & flags */
avio_w8(pb, ctx->use_subsamples ? 0 : AES_CTR_IV_SIZE); /* default size*/
avio_wb32(pb, ctx->auxiliary_info_entries); /* entry count */
if (ctx->use_subsamples) {
avio_write(pb, ctx->auxiliary_info_sizes, ctx->auxiliary_info_entries);
}
return update_size(pb, pos);
}
void ff_mov_cenc_write_stbl_atoms(MOVMuxCencContext* ctx, AVIOContext *pb)
{
int64_t auxiliary_info_offset;
mov_cenc_write_senc_tag(ctx, pb, &auxiliary_info_offset);
mov_cenc_write_saio_tag(pb, auxiliary_info_offset);
mov_cenc_write_saiz_tag(ctx, pb);
}
static int mov_cenc_write_schi_tag(AVIOContext *pb, uint8_t* kid)
{
int64_t pos = avio_tell(pb);
avio_wb32(pb, 0); /* size */
ffio_wfourcc(pb, "schi");
avio_wb32(pb, 32); /* size */
ffio_wfourcc(pb, "tenc");
avio_wb32(pb, 0); /* version & flags */
avio_wb24(pb, 1); /* is encrypted */
avio_w8(pb, AES_CTR_IV_SIZE); /* iv size */
avio_write(pb, kid, CENC_KID_SIZE);
return update_size(pb, pos);
}
int ff_mov_cenc_write_sinf_tag(MOVTrack* track, AVIOContext *pb, uint8_t* kid)
{
int64_t pos = avio_tell(pb);
avio_wb32(pb, 0); /* size */
ffio_wfourcc(pb, "sinf");
/* frma */
avio_wb32(pb, 12); /* size */
ffio_wfourcc(pb, "frma");
avio_wl32(pb, track->tag);
/* schm */
avio_wb32(pb, 20); /* size */
ffio_wfourcc(pb, "schm");
avio_wb32(pb, 0); /* version & flags */
ffio_wfourcc(pb, "cenc"); /* scheme type*/
avio_wb32(pb, 0x10000); /* scheme version */
/* schi */
mov_cenc_write_schi_tag(pb, kid);
return update_size(pb, pos);
}
int ff_mov_cenc_init(MOVMuxCencContext* ctx, uint8_t* encryption_key,
int use_subsamples, int bitexact)
{
int ret;
ctx->aes_ctr = av_aes_ctr_alloc();
if (!ctx->aes_ctr) {
return AVERROR(ENOMEM);
}
ret = av_aes_ctr_init(ctx->aes_ctr, encryption_key);
if (ret != 0) {
return ret;
}
if (!bitexact) {
av_aes_ctr_set_random_iv(ctx->aes_ctr);
}
ctx->use_subsamples = use_subsamples;
return 0;
}
void ff_mov_cenc_free(MOVMuxCencContext* ctx)
{
av_aes_ctr_free(ctx->aes_ctr);
} |