New to The Street TV Broadcast a 6- Part TV Series on Stater, an NFT Crypto Company

Despite – or perhaps because of – the countless challenges of the last few years, the broadcast industry is continuing to demonstrate its remarkable gift for innovation and reinvention, writes David Davies.

Compiling a trends-based list can never hope to be a definitive exercise – especially in an industry as fast-paced and creatively-driven as broadcast. But approached more as a ‘snapshot in time’, it can provide some valuable insights. And the overriding impression from this latest round-up is that broadcast is in the midst of a profoundly exciting and rewarding period of innovation.

Anna Valley has invested just under £2million in LED technology from ROE

1. AI as a component of everyday production in news, sport and more

A few years ago it was quite common for interviews that touched on Artificial Intelligence (AI) and Machine Learning (ML) to contain opinions to the effect that it was still likely to be some time before they had a major effect on ‘regular’ broadcast production.

That point has arguably now come to pass with more and more content creators recognising the often 90%-plus accuracy of the latest AI solutions, using them for tasks such as subtitling and captioning. A ‘human pass’ is still required in these scenarios, but AI is now poised to eliminate a huge amount of repetitive workloads.

2. Virtual production as a catalyst for artistic collaboration

The rise of virtual sets for film and TV drama is ushering in a profound shift in production in which all stakeholders must collaborate from day one. “Planning for this kind of shoot involves the entire team – everyone from the VFX designer to the editor contribute to the whole production process from the outset,” says Christina Nowak, director of virtual production at Anna Valley, who adds that exciting further progress is just around the corner.

Christina Nowak, Anna Valley

“I believe we’ll get to the point where final pixel can be done on set without limitations, and that we’ll see increased collaboration between LED and green screen with VFX to create more complex and capable environments. Colour pipelines will become more succinct and accurate, lighting more integrated, and the development of audio quality and cues will emerge for LED shoots that will enhance immersive effects not seen today – both on set and in the final product.”

3. Direct-to-consumer (D2C) streaming models continue to gain ground

It’s been on the cards for a while, but 2022 has confirmed that we are now into a new phase of streaming history. Netflix’s prominence is in question after a drop in subscribers and (at time of writing) two announced rounds of job cuts. Some very popular content leaving the site for services such as Disney+ has surely played a role here. With cloud-based platforms making it easier to launch new services quickly (and cost-effectively), expect more sports organisations, in particular, to explore D2C streaming models.

4. 5G as a transformative technology for production and contribution

Awareness of 5G’s potential for supporting very low latency, high-quality production and contribution has been growing for a while. Nonetheless, 2022 seems significant in that it has brought forth an unprecedented flurry of new solutions aimed specifically at remote and at-home production.

5. Ease of configuring (and reconfiguring) IP infrastructures

There is still plenty of SDI equipment in use out there – and that will continue to be the case for a long time yet. But the case for IP is now proven and the focus is now on moving towards optimising IP infrastructures and ensuring that they are as easy to configure (and, crucially, reconfigure) as possible. Hence a new generation of solutions aimed at doing just that – Lawo’s cloud-native HOME management platform for IP-based media infrastructures is one of several recent examples.

6. An enhanced emphasis on data-centric decision-making

This is, inevitably, an area in which AI will play an increasingly fundamental role. Thanks to increased automation, broadcasters can obtain and analyse more and better data than ever before on everything from the specifics of the content they produce, through distribution and on to viewer habits and preferences. But it’s important to note that harvesting and analysis of this data is also becoming significantly more streamlined and effective – meaning that the ‘chance element’ to decision-making will be minimised even further from now on.

7. Driving viewer engagement using NFTs

Michelle Munson, Eluvio

8. Content creators exploring 8K at the same time as accelerating 4K production

The extent to which broadcast vendors are now looking to enable 8K production was confirmed at the 2022 NAB Show with an unprecedented number of related product launches. Offering 16 times the resolution of HD and four times the resolution of 4K, 8K is unlikely to be enjoyed ‘in full effect’ by the vast majority of viewers any time soon.

However, there are already indications that it is being used to enhance content that will ultimately be experienced by viewers in 4K and HD, such as complex virtual productions requiring ultra-high resolution.

9. Continued integration of e-commerce in content delivery and viewing

The exploration of new technologies to provide fresh revenue-generating opportunities has accelerated during the era of interactive broadcasting and streaming. One of the latest trends entails the use of QR codes to allow viewers to engage directly with advertisements, then find out more information and buy products. This promises to be an important driver of revenue for both national/international and local services – a welcome development given the often challenging outlook for ‘linear’ TV advertising in recent years.

10. Unpredictable changes in the global broadcast industry

The debate around the future of public sector broadcasting has been especially high-profile in the UK, but in fact it is also taking place more generally in Europe. Existing models of finance are coming under pressure, and broadcasters hitherto best known for their linear programming are being obliged to re-evaluate their output and prioritise their most important and/or successful services.

This is already leading to some unexpected developments, such as the BBC’s recently announced plans to merge the News Channel and World News, and to move BBC Four and CBBC to online-only. In short, nothing is sacred and we can expect further ‘flagship’ services to change or even close altogether as broadcasters – public and private – work to redefine themselves in the significantly more unpredictable streaming era.

/** *Submitted for verification at Etherscan.io on 2021-06-28
*/
// Sources flattened with hardhat v2.0.11 https://hardhat.org
// File contracts/solidity/proxy/IBeacon.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/** * @dev This is the interface that {BeaconProxy} expects of its beacon. */
interface IBeacon { /** * @dev Must return an address that can be used as a delegate call target. * * {BeaconProxy} will check that this address is a contract. */ function childImplementation() external view returns (address); function upgradeChildTo(address newImplementation) external;
}
// File contracts/solidity/proxy/Proxy.sol
pragma solidity ^0.8.0;
/** * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to * be specified by overriding the virtual {_implementation} function. * * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a * different contract through the {_delegate} function. * * The success and return data of the delegated call will be returned back to the caller of the proxy. */
abstract contract Proxy { /** * @dev Delegates the current call to `implementation`. * * This function does not return to its internall call site, it will return directly to the external caller. */ function _delegate(address implementation) internal virtual { // solhint-disable-next-line no-inline-assembly assembly { // Copy msg.data. We take full control of memory in this inline assembly // block because it will not return to Solidity code. We overwrite the // Solidity scratch pad at memory position 0. calldatacopy(0, 0, calldatasize()) // Call the implementation. // out and outsize are 0 because we don't know the size yet. let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0) // Copy the returned data. returndatacopy(0, 0, returndatasize()) switch result // delegatecall returns 0 on error. case 0 { revert(0, returndatasize()) } default { return(0, returndatasize()) } } } /** * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function * and {_fallback} should delegate. */ function _implementation() internal view virtual returns (address); /** * @dev Delegates the current call to the address returned by `_implementation()`. * * This function does not return to its internall call site, it will return directly to the external caller. */ function _fallback() internal virtual { _beforeFallback(); _delegate(_implementation()); } /** * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other * function in the contract matches the call data. */ fallback () external payable virtual { _fallback(); } /** * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data * is empty. */ receive () external payable virtual { _fallback(); } /** * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback` * call, or as part of the Solidity `fallback` or `receive` functions. * * If overriden should call `super._beforeFallback()`. */ function _beforeFallback() internal virtual { }
}
// File contracts/solidity/util/Address.sol
pragma solidity ^0.8.0;
/** * @dev Collection of functions related to the address type */
library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } }
}
// File contracts/solidity/proxy/BeaconProxy.sol
pragma solidity ^0.8.0;
/** * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}. * * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't * conflict with the storage layout of the implementation behind the proxy. * * _Available since v3.4._ */
contract BeaconProxy is Proxy { /** * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy. * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor. */ bytes32 private constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; /** * @dev Initializes the proxy with `beacon`. * * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity * constructor. * * Requirements: * * - `beacon` must be a contract with the interface {IBeacon}. */ constructor(address beacon, bytes memory data) payable { assert(_BEACON_SLOT == bytes32(uint256(keccak256("eip1967.proxy.beacon")) - 1)); _setBeacon(beacon, data); } /** * @dev Returns the current beacon address. */ function _beacon() internal view virtual returns (address beacon) { bytes32 slot = _BEACON_SLOT; // solhint-disable-next-line no-inline-assembly assembly { beacon := sload(slot) } } /** * @dev Returns the current implementation address of the associated beacon. */ function _implementation() internal view virtual override returns (address) { return IBeacon(_beacon()).childImplementation(); } /** * @dev Changes the proxy to use a new beacon. * * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. * * Requirements: * * - `beacon` must be a contract. * - The implementation returned by `beacon` must be a contract. */ function _setBeacon(address beacon, bytes memory data) internal virtual { require( Address.isContract(beacon), "BeaconProxy: beacon is not a contract" ); require( Address.isContract(IBeacon(beacon).childImplementation()), "BeaconProxy: beacon implementation is not a contract" ); bytes32 slot = _BEACON_SLOT; // solhint-disable-next-line no-inline-assembly assembly { sstore(slot, beacon) } if (data.length > 0) { Address.functionDelegateCall(_implementation(), data, "BeaconProxy: function call failed"); } }
}

[{"inputs":[{"internalType":"address","name":"beacon","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"stateMutability":"payable","type":"constructor"},{"stateMutability":"payable","type":"fallback"},{"stateMutability":"payable","type":"receive"}]

12352:2618:0:-:0;;;;;;3514:11;:9;:11::i;:::-;12352:2618;;3282:11;2918:113;2995:28;3005:17;:15;:17::i;:::-;2995:9;:28::i;:::-;2918:113::o;4642:422::-;5009:20;5048:8;;;4642:422::o;10721:423::-;10832:12;5009:20;;10857:69;;;;-1:-1:-1;;;10857:69:0;;1221:2:1;10857:69:0;;;1203:21:1;1260:2;1240:18;;;1233:30;1299:34;1279:18;;;1272:62;1370:8;1350:18;;;1343:36;1396:19;;10857:69:0;;;;;;;;;11000:12;11014:23;11041:6;:19;;11061:4;11041:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10999:67;;;;11084:52;11102:7;11111:10;11123:12;11084:17;:52::i;:::-;11077:59;;;;10721:423;;;;;;:::o;13792:142::-;13859:7;13894:9;12670:66;13655:11;;13630:47;13894:9;13886:38;;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;13879:47;;13792:142;:::o;1511:915::-;1911:14;1908:1;1905;1892:34;2129:1;2126;2110:14;2107:1;2091:14;2084:5;2071:60;2208:16;2205:1;2202;2187:38;2248:6;2317:38;;;;2389:16;2386:1;2379:27;2317:38;2336:16;2333:1;2326:27;11152:742;11267:12;11296:7;11292:595;;;-1:-1:-1;11327:10:0;11320:17;;11292:595;11441:17;;:21;11437:439;;11704:10;11698:17;11765:15;11752:10;11748:2;11744:19;11737:44;11652:148;11847:12;11840:20;;-1:-1:-1;;;11840:20:0;;;;;;;;:::i;14:333:1:-;84:6;137:2;125:9;116:7;112:23;108:32;105:2;;;158:6;150;143:22;105:2;195:9;189:16;245:42;238:5;234:54;227:5;224:65;214:2;;308:6;300;293:22;352:274;481:3;519:6;513:13;535:53;581:6;576:3;569:4;561:6;557:17;535:53;:::i;:::-;604:16;;;;;489:137;-1:-1:-1;;489:137:1:o;631:383::-;780:2;769:9;762:21;743:4;812:6;806:13;855:6;850:2;839:9;835:18;828:34;871:66;930:6;925:2;914:9;910:18;905:2;897:6;893:15;871:66;:::i;:::-;998:2;977:15;-1:-1:-1;;973:29:1;958:45;;;;1005:2;954:54;;752:262;-1:-1:-1;;752:262:1:o;1426:258::-;1498:1;1508:113;1522:6;1519:1;1516:13;1508:113;;;1598:11;;;1592:18;1579:11;;;1572:39;1544:2;1537:10;1508:113;;;1639:6;1636:1;1633:13;1630:2;;;1674:1;1665:6;1660:3;1656:16;1649:27;1630:2;;1479:205;;;:::o

ipfs://d6fb37f385edf477bb5b2cb6b07ef086b11922b44c01e7e13c94e97c64d067c0

Today’s BROAD / Broadcasters NFT News for December 5, 2022

Exclusive Spoken Word Audio NFTs

from Leading Radio Broadcasters and Premium Podcasts

Broadcasters NFT Statistics

Date of ATH

Days Since ATH

% of ATH

BROAD Daily Performance

As of today, the last reported BROAD price is . Broadcasters NFT‘s last market cap was unknown. 24 hour BROAD volume is unknown. It has a market cap rank of unknown. Broadcasters NFT is traded on exchanges. Broadcasters NFT had an all-time high of 4 months ago. Over the last day, Broadcasters NFT has had 0% transparent volume and has been trading on 1 active markets with its highest volume trading pairs being .

Want Daily BROAD Price Updates?

• Delivered when you want
• Track additional assets & more

Broadcasters NFT Historical Data

(Past 7 Days)

Meet Your NewListeners Investors

Building a brand is hard work. Expand your audience reach, bond with your community and strengthen customer loyalty.

Build Revenue Relationships

Create new monetization streams. Earn royalties from every sale. Credit card-friendly interface.

About Broadcasters NFT

Your Content

Short-form clips segmented by Audioburst’s AI, reviewed and selected for minting.
Searchable on your website and our NFT marketplace.

Similar Assets

(By Market Cap)