1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Vidtv serves as a reference DVB driver and helps validate the existing APIs 4 * in the media subsystem. It can also aid developers working on userspace 5 * applications. 6 * 7 * This file contains the code for an AES3 (also known as AES/EBU) encoder. 8 * It is based on EBU Tech 3250 and SMPTE 302M technical documents. 9 * 10 * This encoder currently supports 16bit AES3 subframes using 16bit signed 11 * integers. 12 * 13 * Note: AU stands for Access Unit, and AAU stands for Audio Access Unit 14 * 15 * Copyright (C) 2020 Daniel W. S. Almeida 16 */ 17 18 #define pr_fmt(fmt) KBUILD_MODNAME ":%s, %d: " fmt, __func__, __LINE__ 19 20 #include <linux/types.h> 21 #include <linux/slab.h> 22 #include <linux/crc32.h> 23 #include <linux/vmalloc.h> 24 #include <linux/string.h> 25 #include <linux/kernel.h> 26 #include <linux/jiffies.h> 27 #include <linux/printk.h> 28 #include <linux/ratelimit.h> 29 #include <linux/fixp-arith.h> 30 31 #include <linux/math64.h> 32 #include <asm/byteorder.h> 33 34 #include "vidtv_s302m.h" 35 #include "vidtv_encoder.h" 36 #include "vidtv_common.h" 37 38 #define S302M_SAMPLING_RATE_HZ 48000 39 #define PES_PRIVATE_STREAM_1 0xbd /* PES: private_stream_1 */ 40 #define S302M_BLOCK_SZ 192 41 #define S302M_SIN_LUT_NUM_ELEM 1024 42 43 /* these are retrieved empirically from ffmpeg/libavcodec */ 44 #define FF_S302M_DEFAULT_NUM_FRAMES 1115 45 #define FF_S302M_DEFAULT_PTS_INCREMENT 2090 46 #define FF_S302M_DEFAULT_PTS_OFFSET 100000 47 48 /* Used by the tone generator: number of samples for PI */ 49 #define PI 180 50 51 static const u8 reverse[256] = { 52 /* from ffmpeg */ 53 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 54 0x30, 0xB0, 0x70, 0xF0, 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 55 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, 0x04, 0x84, 0x44, 0xC4, 56 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, 57 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 58 0x3C, 0xBC, 0x7C, 0xFC, 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 59 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, 0x0A, 0x8A, 0x4A, 0xCA, 60 0x2A, 0xAA, 0x6A, 0xEA, 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, 61 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 62 0x36, 0xB6, 0x76, 0xF6, 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 63 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, 0x01, 0x81, 0x41, 0xC1, 64 0x21, 0xA1, 0x61, 0xE1, 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, 65 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 66 0x39, 0xB9, 0x79, 0xF9, 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 67 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, 0x0D, 0x8D, 0x4D, 0xCD, 68 0x2D, 0xAD, 0x6D, 0xED, 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, 69 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 70 0x33, 0xB3, 0x73, 0xF3, 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 71 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, 0x07, 0x87, 0x47, 0xC7, 72 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, 73 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 74 0x3F, 0xBF, 0x7F, 0xFF, 75 }; 76 77 struct tone_duration { 78 enum musical_notes note; 79 int duration; 80 }; 81 82 #define COMPASS 120 /* beats per minute (Allegro) */ 83 static const struct tone_duration beethoven_5th_symphony[] = { 84 { NOTE_E_6, 128}, { NOTE_DS_6, 128}, { NOTE_E_6, 128}, 85 { NOTE_DS_6, 128}, { NOTE_E_6, 128}, { NOTE_B_5, 128}, 86 { NOTE_D_6, 128}, { NOTE_C_6, 128}, { NOTE_A_3, 128}, 87 { NOTE_E_4, 128}, { NOTE_A_4, 128}, { NOTE_C_5, 128}, 88 { NOTE_E_5, 128}, { NOTE_A_5, 128}, { NOTE_E_3, 128}, 89 { NOTE_E_4, 128}, { NOTE_GS_4, 128}, { NOTE_E_5, 128}, 90 { NOTE_GS_5, 128}, { NOTE_B_5, 128}, { NOTE_A_3, 128}, 91 { NOTE_E_4, 128}, { NOTE_A_4, 128}, { NOTE_E_5, 128}, 92 { NOTE_E_6, 128}, { NOTE_DS_6, 128}, { NOTE_E_6, 128}, 93 { NOTE_DS_6, 128}, { NOTE_E_6, 128}, { NOTE_B_5, 128}, 94 { NOTE_D_6, 128}, { NOTE_C_6, 128}, { NOTE_A_3, 128}, 95 { NOTE_E_4, 128}, { NOTE_A_4, 128}, { NOTE_C_5, 128}, 96 { NOTE_E_5, 128}, { NOTE_A_5, 128}, { NOTE_E_3, 128}, 97 { NOTE_E_4, 128}, { NOTE_GS_4, 128}, { NOTE_E_5, 128}, 98 { NOTE_C_6, 128}, { NOTE_B_5, 128}, { NOTE_A_3, 128}, 99 { NOTE_E_4, 128}, { NOTE_A_4, 128}, { NOTE_SILENT, 128}, 100 101 { NOTE_E_6, 128}, { NOTE_DS_6, 128}, { NOTE_E_6, 128}, 102 { NOTE_DS_6, 128}, { NOTE_E_6, 128}, { NOTE_B_5, 128}, 103 { NOTE_D_6, 128}, { NOTE_C_6, 128}, { NOTE_A_3, 128}, 104 { NOTE_E_4, 128}, { NOTE_A_4, 128}, { NOTE_C_5, 128}, 105 { NOTE_E_5, 128}, { NOTE_A_5, 128}, { NOTE_E_3, 128}, 106 { NOTE_E_4, 128}, { NOTE_GS_4, 128}, { NOTE_E_5, 128}, 107 { NOTE_GS_5, 128}, { NOTE_B_5, 128}, { NOTE_A_3, 128}, 108 { NOTE_E_4, 128}, { NOTE_A_4, 128}, { NOTE_E_5, 128}, 109 { NOTE_E_6, 128}, { NOTE_DS_6, 128}, { NOTE_E_6, 128}, 110 { NOTE_DS_6, 128}, { NOTE_E_6, 128}, { NOTE_B_5, 128}, 111 { NOTE_D_6, 128}, { NOTE_C_6, 128}, { NOTE_A_3, 128}, 112 { NOTE_E_4, 128}, { NOTE_A_4, 128}, { NOTE_C_5, 128}, 113 { NOTE_E_5, 128}, { NOTE_A_5, 128}, { NOTE_E_3, 128}, 114 { NOTE_E_4, 128}, { NOTE_GS_4, 128}, { NOTE_E_5, 128}, 115 { NOTE_C_6, 128}, { NOTE_B_5, 128}, { NOTE_A_3, 128}, 116 { NOTE_E_4, 128}, { NOTE_A_4, 128}, { NOTE_B_4, 128}, 117 { NOTE_C_5, 128}, { NOTE_D_5, 128}, { NOTE_C_4, 128}, 118 { NOTE_G_4, 128}, { NOTE_C_5, 128}, { NOTE_G_4, 128}, 119 { NOTE_F_5, 128}, { NOTE_E_5, 128}, { NOTE_G_3, 128}, 120 { NOTE_G_4, 128}, { NOTE_B_3, 128}, { NOTE_F_4, 128}, 121 { NOTE_E_5, 128}, { NOTE_D_5, 128}, { NOTE_A_3, 128}, 122 { NOTE_E_4, 128}, { NOTE_A_4, 128}, { NOTE_E_4, 128}, 123 { NOTE_D_5, 128}, { NOTE_C_5, 128}, { NOTE_E_3, 128}, 124 { NOTE_E_4, 128}, { NOTE_E_5, 255}, { NOTE_E_6, 128}, 125 { NOTE_E_5, 128}, { NOTE_E_6, 128}, { NOTE_E_5, 255}, 126 { NOTE_DS_5, 128}, { NOTE_E_5, 128}, { NOTE_DS_6, 128}, 127 { NOTE_E_6, 128}, { NOTE_DS_5, 128}, { NOTE_E_5, 128}, 128 { NOTE_DS_6, 128}, { NOTE_E_6, 128}, { NOTE_DS_6, 128}, 129 { NOTE_E_6, 128}, { NOTE_DS_6, 128}, { NOTE_E_6, 128}, 130 { NOTE_B_5, 128}, { NOTE_D_6, 128}, { NOTE_C_6, 128}, 131 { NOTE_A_3, 128}, { NOTE_E_4, 128}, { NOTE_A_4, 128}, 132 { NOTE_C_5, 128}, { NOTE_E_5, 128}, { NOTE_A_5, 128}, 133 { NOTE_E_3, 128}, { NOTE_E_4, 128}, { NOTE_GS_4, 128}, 134 { NOTE_E_5, 128}, { NOTE_GS_5, 128}, { NOTE_B_5, 128}, 135 { NOTE_A_3, 128}, { NOTE_E_4, 128}, { NOTE_A_4, 128}, 136 { NOTE_E_5, 128}, { NOTE_E_6, 128}, { NOTE_DS_6, 128}, 137 { NOTE_E_6, 128}, { NOTE_DS_6, 128}, { NOTE_E_6, 128}, 138 { NOTE_B_5, 128}, { NOTE_D_6, 128}, { NOTE_C_6, 128}, 139 { NOTE_A_3, 128}, { NOTE_E_4, 128}, { NOTE_A_4, 128}, 140 { NOTE_C_5, 128}, { NOTE_E_5, 128}, { NOTE_A_5, 128}, 141 { NOTE_E_3, 128}, { NOTE_E_4, 128}, { NOTE_GS_4, 128}, 142 { NOTE_E_5, 128}, { NOTE_C_6, 128}, { NOTE_B_5, 128}, 143 { NOTE_C_5, 255}, { NOTE_C_5, 255}, { NOTE_SILENT, 512}, 144 }; 145 146 static struct vidtv_access_unit *vidtv_s302m_access_unit_init(struct vidtv_access_unit *head) 147 { 148 struct vidtv_access_unit *au = kzalloc(sizeof(*au), GFP_KERNEL); 149 150 if (head) { 151 while (head->next) 152 head = head->next; 153 154 head->next = au; 155 } 156 157 return au; 158 } 159 160 static void vidtv_s302m_access_unit_destroy(struct vidtv_encoder *e) 161 { 162 struct vidtv_access_unit *head = e->access_units; 163 struct vidtv_access_unit *tmp = NULL; 164 165 while (head) { 166 tmp = head; 167 head = head->next; 168 kfree(tmp); 169 } 170 171 e->access_units = NULL; 172 } 173 174 static void vidtv_s302m_alloc_au(struct vidtv_encoder *e) 175 { 176 struct vidtv_access_unit *sync_au = NULL; 177 struct vidtv_access_unit *temp = NULL; 178 179 if (e->sync && e->sync->is_video_encoder) { 180 sync_au = e->sync->access_units; 181 182 while (sync_au) { 183 temp = vidtv_s302m_access_unit_init(e->access_units); 184 if (!e->access_units) 185 e->access_units = temp; 186 187 sync_au = sync_au->next; 188 } 189 190 return; 191 } 192 193 e->access_units = vidtv_s302m_access_unit_init(NULL); 194 } 195 196 static void 197 vidtv_s302m_compute_sample_count_from_video(struct vidtv_encoder *e) 198 { 199 struct vidtv_access_unit *au = e->access_units; 200 struct vidtv_access_unit *sync_au = e->sync->access_units; 201 u32 vau_duration_usecs; 202 u32 sample_duration_usecs; 203 u32 s; 204 205 vau_duration_usecs = USEC_PER_SEC / e->sync->sampling_rate_hz; 206 sample_duration_usecs = USEC_PER_SEC / e->sampling_rate_hz; 207 208 while (au && sync_au) { 209 s = DIV_ROUND_UP(vau_duration_usecs, sample_duration_usecs); 210 au->num_samples = s; 211 au = au->next; 212 sync_au = sync_au->next; 213 } 214 } 215 216 static void vidtv_s302m_compute_pts_from_video(struct vidtv_encoder *e) 217 { 218 struct vidtv_access_unit *au = e->access_units; 219 struct vidtv_access_unit *sync_au = e->sync->access_units; 220 221 /* use the same pts from the video access unit*/ 222 while (au && sync_au) { 223 au->pts = sync_au->pts; 224 au = au->next; 225 sync_au = sync_au->next; 226 } 227 } 228 229 static u16 vidtv_s302m_get_sample(struct vidtv_encoder *e) 230 { 231 u16 sample; 232 int pos; 233 234 if (!e->src_buf) { 235 /* 236 * Simple tone generator: play the tones at the 237 * beethoven_5th_symphony array. 238 */ 239 if (e->last_duration <= 0) { 240 if (e->src_buf_offset >= ARRAY_SIZE(beethoven_5th_symphony)) 241 e->src_buf_offset = 0; 242 243 e->last_tone = beethoven_5th_symphony[e->src_buf_offset].note; 244 e->last_duration = beethoven_5th_symphony[e->src_buf_offset].duration * S302M_SAMPLING_RATE_HZ / COMPASS / 5; 245 e->src_buf_offset++; 246 e->note_offset = 0; 247 } else { 248 e->last_duration--; 249 } 250 251 /* Handle silent */ 252 if (!e->last_tone) { 253 e->src_buf_offset = 0; 254 return 0x8000; 255 } 256 257 pos = (2 * PI * e->note_offset * e->last_tone / S302M_SAMPLING_RATE_HZ); 258 259 if (pos == 360) 260 e->note_offset = 0; 261 else 262 e->note_offset++; 263 264 return (fixp_sin32(pos % (2 * PI)) >> 16) + 0x8000; 265 } 266 267 /* bug somewhere */ 268 if (e->src_buf_offset > e->src_buf_sz) { 269 pr_err_ratelimited("overflow detected: %d > %d, wrapping.\n", 270 e->src_buf_offset, 271 e->src_buf_sz); 272 273 e->src_buf_offset = 0; 274 } 275 276 if (e->src_buf_offset >= e->src_buf_sz) { 277 /* let the source know we are out of data */ 278 if (e->last_sample_cb) 279 e->last_sample_cb(e->sample_count); 280 281 e->src_buf_offset = 0; 282 } 283 284 sample = *(u16 *)(e->src_buf + e->src_buf_offset); 285 286 return sample; 287 } 288 289 static u32 vidtv_s302m_write_frame(struct vidtv_encoder *e, 290 u16 sample) 291 { 292 u32 nbytes = 0; 293 struct vidtv_s302m_frame_16 f = {}; 294 struct vidtv_s302m_ctx *ctx = e->ctx; 295 296 /* from ffmpeg: see s302enc.c */ 297 298 u8 vucf = ctx->frame_index == 0 ? 0x10 : 0; 299 300 f.data[0] = sample & 0xFF; 301 f.data[1] = (sample & 0xFF00) >> 8; 302 f.data[2] = ((sample & 0x0F) << 4) | vucf; 303 f.data[3] = (sample & 0x0FF0) >> 4; 304 f.data[4] = (sample & 0xF000) >> 12; 305 306 f.data[0] = reverse[f.data[0]]; 307 f.data[1] = reverse[f.data[1]]; 308 f.data[2] = reverse[f.data[2]]; 309 f.data[3] = reverse[f.data[3]]; 310 f.data[4] = reverse[f.data[4]]; 311 312 nbytes += vidtv_memcpy(e->encoder_buf, 313 e->encoder_buf_offset, 314 VIDTV_S302M_BUF_SZ, 315 &f, 316 sizeof(f)); 317 318 e->encoder_buf_offset += nbytes; 319 320 ctx->frame_index++; 321 if (ctx->frame_index >= S302M_BLOCK_SZ) 322 ctx->frame_index = 0; 323 324 return nbytes; 325 } 326 327 static u32 vidtv_s302m_write_h(struct vidtv_encoder *e, u32 p_sz) 328 { 329 struct vidtv_smpte_s302m_es h = {}; 330 u32 nbytes = 0; 331 332 /* 2 channels, ident: 0, 16 bits per sample */ 333 h.bitfield = cpu_to_be32((p_sz << 16)); 334 335 nbytes += vidtv_memcpy(e->encoder_buf, 336 e->encoder_buf_offset, 337 e->encoder_buf_sz, 338 &h, 339 sizeof(h)); 340 341 e->encoder_buf_offset += nbytes; 342 return nbytes; 343 } 344 345 static void vidtv_s302m_write_frames(struct vidtv_encoder *e) 346 { 347 struct vidtv_access_unit *au = e->access_units; 348 struct vidtv_s302m_ctx *ctx = e->ctx; 349 u32 nbytes_per_unit = 0; 350 u32 nbytes = 0; 351 u32 au_sz = 0; 352 u16 sample; 353 u32 j; 354 355 while (au) { 356 au_sz = au->num_samples * 357 sizeof(struct vidtv_s302m_frame_16); 358 359 nbytes_per_unit = vidtv_s302m_write_h(e, au_sz); 360 361 for (j = 0; j < au->num_samples; ++j) { 362 sample = vidtv_s302m_get_sample(e); 363 nbytes_per_unit += vidtv_s302m_write_frame(e, sample); 364 365 if (e->src_buf) 366 e->src_buf_offset += sizeof(u16); 367 368 e->sample_count++; 369 } 370 371 au->nbytes = nbytes_per_unit; 372 373 if (au_sz + sizeof(struct vidtv_smpte_s302m_es) != nbytes_per_unit) { 374 pr_warn_ratelimited("write size was %u, expected %zu\n", 375 nbytes_per_unit, 376 au_sz + sizeof(struct vidtv_smpte_s302m_es)); 377 } 378 379 nbytes += nbytes_per_unit; 380 au->offset = nbytes - nbytes_per_unit; 381 382 nbytes_per_unit = 0; 383 ctx->au_count++; 384 385 au = au->next; 386 } 387 } 388 389 static void *vidtv_s302m_encode(struct vidtv_encoder *e) 390 { 391 /* 392 * According to SMPTE 302M, an audio access unit is specified as those 393 * AES3 words that are associated with a corresponding video frame. 394 * Therefore, there is one audio access unit for every video access unit 395 * in the corresponding video encoder ('sync'), using the same values 396 * for PTS as used by the video encoder. 397 * 398 * Assuming that it is also possible to send audio without any 399 * associated video, as in a radio-like service, a single audio access unit 400 * is created with values for 'num_samples' and 'pts' taken empirically from 401 * ffmpeg 402 */ 403 404 struct vidtv_s302m_ctx *ctx = e->ctx; 405 406 vidtv_s302m_access_unit_destroy(e); 407 vidtv_s302m_alloc_au(e); 408 409 if (e->sync && e->sync->is_video_encoder) { 410 vidtv_s302m_compute_sample_count_from_video(e); 411 vidtv_s302m_compute_pts_from_video(e); 412 } else { 413 e->access_units->num_samples = FF_S302M_DEFAULT_NUM_FRAMES; 414 e->access_units->pts = (ctx->au_count * FF_S302M_DEFAULT_PTS_INCREMENT) + 415 FF_S302M_DEFAULT_PTS_OFFSET; 416 } 417 418 vidtv_s302m_write_frames(e); 419 420 return e->encoder_buf; 421 } 422 423 static u32 vidtv_s302m_clear(struct vidtv_encoder *e) 424 { 425 struct vidtv_access_unit *au = e->access_units; 426 u32 count = 0; 427 428 while (au) { 429 count++; 430 au = au->next; 431 } 432 433 vidtv_s302m_access_unit_destroy(e); 434 memset(e->encoder_buf, 0, VIDTV_S302M_BUF_SZ); 435 e->encoder_buf_offset = 0; 436 437 return count; 438 } 439 440 struct vidtv_encoder 441 *vidtv_s302m_encoder_init(struct vidtv_s302m_encoder_init_args args) 442 { 443 struct vidtv_encoder *e = kzalloc(sizeof(*e), GFP_KERNEL); 444 u32 priv_sz = sizeof(struct vidtv_s302m_ctx); 445 446 e->id = S302M; 447 448 if (args.name) 449 e->name = kstrdup(args.name, GFP_KERNEL); 450 451 e->encoder_buf = vzalloc(VIDTV_S302M_BUF_SZ); 452 e->encoder_buf_sz = VIDTV_S302M_BUF_SZ; 453 e->encoder_buf_offset = 0; 454 455 e->sample_count = 0; 456 e->last_duration = 0; 457 458 e->src_buf = (args.src_buf) ? args.src_buf : NULL; 459 e->src_buf_sz = (args.src_buf) ? args.src_buf_sz : 0; 460 e->src_buf_offset = 0; 461 462 e->is_video_encoder = false; 463 e->ctx = kzalloc(priv_sz, GFP_KERNEL); 464 465 e->encode = vidtv_s302m_encode; 466 e->clear = vidtv_s302m_clear; 467 468 e->es_pid = cpu_to_be16(args.es_pid); 469 e->stream_id = cpu_to_be16(PES_PRIVATE_STREAM_1); 470 471 e->sync = args.sync; 472 e->sampling_rate_hz = S302M_SAMPLING_RATE_HZ; 473 474 e->last_sample_cb = args.last_sample_cb; 475 476 e->destroy = vidtv_s302m_encoder_destroy; 477 478 if (args.head) { 479 while (args.head->next) 480 args.head = args.head->next; 481 482 args.head->next = e; 483 } 484 485 e->next = NULL; 486 487 return e; 488 } 489 490 void vidtv_s302m_encoder_destroy(struct vidtv_encoder *e) 491 { 492 if (e->id != S302M) { 493 pr_err_ratelimited("Encoder type mismatch, skipping.\n"); 494 return; 495 } 496 497 vidtv_s302m_access_unit_destroy(e); 498 kfree(e->name); 499 vfree(e->encoder_buf); 500 kfree(e->ctx); 501 kfree(e); 502 } 503